From 82aa787ed30f7afaa3c6cf4041b3448d0bce6139 Mon Sep 17 00:00:00 2001
From: Andrew McIntosh <nacho.vonkickbutt@gmail.com>
Date: Fri, 10 Oct 2025 23:12:18 -0400
Subject: [PATCH 1/3] refactor: Enable style checks in CI and fix styling

The original work to add the CI left the flak8 and black checks passing
on failures. This was due to the number of style fixes that needed to be
addressed in a future PR.

This work:

- Updates the CI action to fail on flake8 and black violations.
- Moves to the "Flake8-pyproject" library as the regular flake8 library
  does not read config from pyproject.toml (just .flake8 or setup.cfg)
- Runs black against all files in alix/ and tests/
- Runs flake8 against all files and corrects any violations
---
 .github/workflows/ci.yml     |   6 +-
 Makefile                     |   6 +-
 alix/cli.py                  | 141 +++++++++++++-------------
 alix/clipboard.py            |   2 +-
 alix/config.py               |   2 +-
 alix/history_manager.py      |   1 -
 alix/models.py               |  22 ++--
 alix/porter.py               |  17 ++--
 alix/render.py               |  16 +--
 alix/scanner.py              |   2 +-
 alix/shell_detector.py       |  16 ++-
 alix/shell_integrator.py     |  41 +++-----
 alix/shell_wrapper.py        |  68 ++++++-------
 alix/storage.py              |  16 ++-
 alix/template_manager.py     |  11 +-
 alix/tui.py                  | 163 +++++++++++-------------------
 alix/usage_tracker.py        | 101 ++++++++-----------
 pyproject.toml               |   3 +-
 tests/test_cli.py            |  41 ++------
 tests/test_fuzzy_search.py   |   1 -
 tests/test_porter.py         |  33 ++----
 tests/test_scanner.py        |  13 +--
 tests/test_storage.py        |  29 ++----
 tests/test_tui.py            |   4 +-
 tests/test_undo_redo.py      |  35 +++----
 tests/test_usage_tracking.py | 190 ++++++++++++++++-------------------
 26 files changed, 407 insertions(+), 573 deletions(-)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index e60773b..5a892f4 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -27,11 +27,9 @@ jobs:
 
       - name: Run black formatting check
         run: alix-venv/bin/black --check .
-        continue-on-error: true # TODO: Fix formatting issues in separate PR
 
       - name: Run flake8 linting
-        run: alix-venv/bin/flake8 .
-        continue-on-error: true # TODO: Fix linting issues in separate P
+        run: make check-style
 
       - name: Run tests
-        run: alix-venv/bin/pytest --tb=short
+        run: make test
diff --git a/Makefile b/Makefile
index 8d5c2ee..7f20cac 100644
--- a/Makefile
+++ b/Makefile
@@ -1,4 +1,4 @@
-.PHONY: help install dev-install test clean venv
+.PHONY: help install dev-install check-style test clean venv
 
 VENV = alix-venv
 PYTHON = $(VENV)/bin/python
@@ -17,6 +17,10 @@ install: venv  ## Install alix in production mode
 dev-install: venv  ## Install alix with dev dependencies
 	$(PIP) install -e ".[dev]"
 
+check-style: dev-install  ## Run style checks
+	$(VENV)/bin/flake8 alix --count --show-source --statistics
+	$(VENV)/bin/flake8 tests --count --show-source --statistics
+
 test: dev-install  ## Run tests
 	$(VENV)/bin/pytest
 
diff --git a/alix/cli.py b/alix/cli.py
index 2eae93a..8b6cbf5 100644
--- a/alix/cli.py
+++ b/alix/cli.py
@@ -1,26 +1,24 @@
-import click
+import json
 import subprocess
-from pathlib import Path
 from datetime import datetime
+from pathlib import Path
+
+import click
 from rich.console import Console
+from rich.markdown import Markdown
 from rich.panel import Panel
 from rich.table import Table
-from rich.prompt import Confirm
-from rich.markdown import Markdown
 
 from alix import __version__
+from alix.config import Config
 from alix.models import Alias
-from alix.storage import AliasStorage
-from alix.shell_integrator import ShellIntegrator
-from alix.shell_detector import ShellType
-from alix.scanner import AliasScanner
 from alix.porter import AliasPorter
-from alix.config import Config
-from alix.history_manager import HistoryManager
-from click.shell_completion import shell_complete as _click_shell_complete
-from alix.shell_wrapper import ShellWrapper
-import json
 from alix.render import Render
+from alix.scanner import AliasScanner
+from alix.shell_detector import ShellType
+from alix.shell_integrator import ShellIntegrator
+from alix.shell_wrapper import ShellWrapper
+from alix.storage import AliasStorage
 from alix.template_manager import TemplateManager
 
 console = Console()
@@ -67,7 +65,10 @@ def add(name, command, description, tags, no_apply, force):
                 "bash",
                 "-i",
                 "-c",
-                f"(alias; declare -f) | /usr/bin/which --tty-only --read-alias --read-functions --show-tilde --show-dot {name}",
+                (
+                    "(alias; declare -f) | /usr/bin/which --tty-only --read-alias "
+                    f"--read-functions --show-tilde --show-dot {name}"
+                ),
             ],
             capture_output=True,
             text=True,
@@ -102,7 +103,7 @@ def add(name, command, description, tags, no_apply, force):
                 console.print(f"[dim]   For current session, run: source ~/{integrator.get_target_file().name}[/]")
             else:
                 console.print(f"[yellow]⚠[/] Alias saved but not applied: {message}")
-                console.print(f"[dim]   Run 'alix apply' to apply all aliases to shell[/]")
+                console.print("[dim]   Run 'alix apply' to apply all aliases to shell[/]")
     else:
         console.print(f"[red]✗[/] Alias '{name}' already exists in alix!\nEdit the alias to override it")
 
@@ -114,7 +115,6 @@ def add(name, command, description, tags, no_apply, force):
 @click.option("--no-apply", is_flag=True, help="Don't apply to shell immediately")
 def edit(name, command, description, no_apply):
     """Add a new alias to your collection and apply it immediately"""
-    msg = None
 
     alias = storage.get(name)
     if alias is None:
@@ -164,7 +164,7 @@ def edit(name, command, description, no_apply):
                 console.print(f"[dim]   For current session, run: source ~/{integrator.get_target_file().name}[/]")
             else:
                 console.print(f"[yellow]⚠[/] Alias saved but not applied: {message}")
-                console.print(f"[dim]   Run 'alix apply' to apply all aliases to shell[/]")
+                console.print("[dim]   Run 'alix apply' to apply all aliases to shell[/]")
 
 
 @main.command()
@@ -255,7 +255,6 @@ def completion(shell, install):
         return
 
     # FIXED: Updated to use Click 8.x shell completion API
-    instruction = f"{target_shell}_source"
     complete_var = "_ALIX_COMPLETE"
 
     # Get the shell completion script
@@ -337,9 +336,9 @@ def apply(shell, file, install_completions, dry_run):
     if success:
         console.print(f"[green]✔[/] {message}")
         console.print("\n[bold]Next steps:[/]")
-        console.print(f"  1. Restart your terminal, OR")
+        console.print("  1. Restart your terminal, OR")
         console.print(f"  2. Run: [cyan]source {target_file}[/]")
-        console.print(f"\n[dim]Your aliases are now ready to use![/]")
+        console.print("\n[dim]Your aliases are now ready to use![/]")
     else:
         console.print(f"[red]✗[/] {message}")
         return
@@ -423,7 +422,7 @@ def stats(detailed, export):
 
         # Recently used aliases
         if analytics["recently_used"]:
-            console.print(f"\n[green]🔥 Recently Used (7 days):[/]")
+            console.print("\n[green]🔥 Recently Used (7 days):[/]")
             for alias_name in analytics["recently_used"][:10]:  # Show first 10
                 alias = storage.get(alias_name)
                 if alias:
@@ -431,7 +430,7 @@ def stats(detailed, export):
 
         # Most productive aliases
         if analytics["most_productive_aliases"]:
-            console.print(f"\n[bold]💪 Most Productive Aliases:[/]")
+            console.print("\n[bold]💪 Most Productive Aliases:[/]")
             table = Table(show_header=True, header_style="bold cyan")
             table.add_column("Rank", style="dim", width=6)
             table.add_column("Alias", style="cyan")
@@ -446,13 +445,13 @@ def stats(detailed, export):
 
         # Usage trends (last 7 days)
         if analytics["usage_trends"]:
-            console.print(f"\n[bold]📅 Usage Trends (Last 7 Days):[/]")
+            console.print("\n[bold]📅 Usage Trends (Last 7 Days):[/]")
             recent_days = sorted(analytics["usage_trends"].items(), reverse=True)[:7]
             for date, count in recent_days:
                 console.print(f"  {date}: {count} uses")
 
     # Show top 5 space savers
-    console.print(f"\n[bold]🏆 Top Commands by Length Saved:[/]")
+    console.print("\n[bold]🏆 Top Commands by Length Saved:[/]")
     sorted_aliases = sorted(aliases, key=lambda a: len(a.command) - len(a.name), reverse=True)[:5]
 
     sorted_aliases = sorted(aliases, key=lambda a: len(a.command) - len(a.name), reverse=True)[:5]
@@ -706,7 +705,7 @@ def history(days, alias):
             total_recent_usage = sum(count for _, count in recent_days)
             console.print(f"Total usage in last {days} days: {total_recent_usage}")
 
-            console.print(f"\n[bold]Daily Breakdown:[/]")
+            console.print("\n[bold]Daily Breakdown:[/]")
             for date, count in recent_days:
                 console.print(f"  {date}: {count} uses")
         else:
@@ -750,7 +749,7 @@ def setup_tracking(shell, file, standalone, output):
             console.print(f"[green]✔[/] Standalone tracking script created: [cyan]{output}[/]")
             console.print(f"[dim]To use: source {output}[/]")
         else:
-            console.print(f"[red]✗[/] Failed to create tracking script")
+            console.print("[red]✗[/] Failed to create tracking script")
     else:
         # Install into shell config
         if file:
@@ -768,7 +767,7 @@ def setup_tracking(shell, file, standalone, output):
             console.print(f"[green]✔[/] Usage tracking installed in: [cyan]{config_file}[/]")
             console.print(f"[dim]Restart your shell or run: source {config_file}[/]")
         else:
-            console.print(f"[red]✗[/] Failed to install tracking integration")
+            console.print("[red]✗[/] Failed to install tracking integration")
 
 
 @main.command()
@@ -837,7 +836,7 @@ def list_aliases():
             table.add_row(alias.name, alias.command, tags_str)
 
     console.print(table)
-    console.print(f"\n[dim]💡 Tip: Run 'alix' for interactive mode![/]")
+    console.print("\n[dim]💡 Tip: Run 'alix' for interactive mode![/]")
 
 
 @main.group()
@@ -846,9 +845,9 @@ def group():
     pass
 
 
-@group.command()
+@group.command("create")
 @click.option("--name", "-n", prompt=True, help="Group name")
-def create(name):
+def create_group(name):
     """Create a new group (shows existing aliases that can be assigned)"""
     aliases = storage.list_all()
     ungrouped_aliases = [a for a in aliases if not a.group]
@@ -861,7 +860,7 @@ def create(name):
     console.print(f"[dim]Found {len(ungrouped_aliases)} ungrouped aliases[/]")
 
     # Show ungrouped aliases
-    table = Table(title=f"Ungrouped Aliases")
+    table = Table(title="Ungrouped Aliases")
     table.add_column("Name", style="cyan")
     table.add_column("Command", style="white")
     table.add_column("Description", style="dim")
@@ -877,8 +876,8 @@ def create(name):
     console.print(f"\n[dim]💡 Use 'alix group add {name} <alias_name>' to add aliases to this group[/]")
 
 
-@group.command()
-def list():
+@group.command("list")
+def list_group():
     """List all groups and their aliases"""
     aliases = storage.list_all()
     groups = {}
@@ -912,10 +911,10 @@ def list():
         console.print(table)
 
 
-@group.command()
+@group.command("add")
 @click.argument("group_name")
 @click.argument("alias_name")
-def add(group_name, alias_name):
+def add_group(group_name, alias_name):
     """Add an alias to a group"""
     alias = storage.get(alias_name)
     if not alias:
@@ -946,10 +945,10 @@ def add(group_name, alias_name):
     console.print(f"[green]✔[/] Added '{alias_name}' to group '{group_name}'")
 
 
-@group.command()
+@group.command("remove")
 @click.argument("group_name")
 @click.argument("alias_name")
-def remove(group_name, alias_name):
+def remove_group(group_name, alias_name):
     """Remove an alias from a group"""
     alias = storage.get(alias_name)
     if not alias:
@@ -979,11 +978,11 @@ def remove(group_name, alias_name):
     console.print(f"[green]✔[/] Removed '{alias_name}' from group '{group_name}'")
 
 
-@group.command()
+@group.command("delete")
 @click.argument("group_name")
 @click.option("--reassign", help="Reassign aliases to this group instead of deleting")
 @click.confirmation_option(prompt="Are you sure you want to delete this group?")
-def delete(group_name, reassign):
+def delete_group(group_name, reassign):
     """Delete a group and optionally reassign aliases"""
     aliases = storage.list_all()
     group_aliases = [a for a in aliases if a.group == group_name]
@@ -1035,7 +1034,7 @@ def delete(group_name, reassign):
         console.print(f"[green]✔[/] Removed group '{group_name}' from {len(group_aliases)} aliases")
 
 
-@group.command()
+@group.command("import")
 @click.argument("file", type=click.Path(exists=True))
 @click.option("--group", "-g", help="Import to specific group (overrides file group)")
 def import_group(file, group):
@@ -1045,7 +1044,7 @@ def import_group(file, group):
             data = json.load(f)
 
         if "aliases" not in data:
-            console.print(f"[red]✗[/] Invalid group export file")
+            console.print("[red]✗[/] Invalid group export file")
             return
 
         target_group = group or data.get("group", "imported")
@@ -1084,10 +1083,10 @@ def import_group(file, group):
         console.print(f"[red]✗[/] Failed to import: {e}")
 
 
-@group.command()
+@group.command("apply")
 @click.argument("group_name")
 @click.option("--apply", is_flag=True, help="Apply all aliases in group to shell")
-def apply(group_name, apply):
+def apply_group(group_name, apply):
     """Apply all aliases in a group to shell"""
     aliases = storage.list_all()
     group_aliases = [a for a in aliases if a.group == group_name]
@@ -1123,8 +1122,8 @@ def tag():
     pass
 
 
-@tag.command()
-def list():
+@tag.command("list")
+def list_tag():
     """List all tags and their usage"""
     aliases = storage.list_all()
     tag_counts = {}
@@ -1157,9 +1156,9 @@ def list():
     console.print(table)
 
 
-@tag.command()
+@tag.command("show")
 @click.argument("tag_name")
-def show(tag_name):
+def show_tag(tag_name):
     """Show all aliases with a specific tag"""
     aliases = storage.list_all()
     tagged_aliases = [a for a in aliases if tag_name in a.tags]
@@ -1188,10 +1187,10 @@ def show(tag_name):
     console.print(table)
 
 
-@tag.command()
+@tag.command("add")
 @click.argument("alias_name")
 @click.argument("tags", nargs=-1, required=True)
-def add(alias_name, tags):
+def add_tag(alias_name, tags):
     """Add tags to an alias"""
     alias = storage.get(alias_name)
     if not alias:
@@ -1227,10 +1226,10 @@ def add(alias_name, tags):
         console.print(f"[yellow]⚠[/] All specified tags already exist for '{alias_name}'")
 
 
-@tag.command()
+@tag.command("remove")
 @click.argument("alias_name")
 @click.argument("tags", nargs=-1, required=True)
-def remove(alias_name, tags):
+def remove_tag(alias_name, tags):
     """Remove tags from an alias"""
     alias = storage.get(alias_name)
     if not alias:
@@ -1264,16 +1263,16 @@ def remove(alias_name, tags):
         if alias.tags:
             console.print(f"[dim]Remaining tags: {', '.join(alias.tags)}[/]")
         else:
-            console.print(f"[dim]No tags remaining[/]")
+            console.print("[dim]No tags remaining[/]")
     else:
         console.print(f"[yellow]⚠[/] None of the specified tags exist for '{alias_name}'")
 
 
-@tag.command()
+@tag.command("rename")
 @click.argument("old_tag")
 @click.argument("new_tag")
 @click.option("--dry-run", is_flag=True, help="Show what would be changed without making changes")
-def rename(old_tag, new_tag, dry_run):
+def rename_tag(old_tag, new_tag, dry_run):
     """Rename a tag across all aliases"""
     aliases = storage.list_all()
     affected_aliases = [a for a in aliases if old_tag in a.tags]
@@ -1321,10 +1320,10 @@ def rename(old_tag, new_tag, dry_run):
     console.print(f"[green]✓[/] Renamed tag in {updated_count} aliases")
 
 
-@tag.command()
+@tag.command("delete")
 @click.argument("tag_name")
 @click.option("--dry-run", is_flag=True, help="Show what would be changed without making changes")
-def delete(tag_name, dry_run):
+def delete_tag(tag_name, dry_run):
     """Delete a tag from all aliases"""
     aliases = storage.list_all()
     affected_aliases = [a for a in aliases if tag_name in a.tags]
@@ -1380,7 +1379,7 @@ def import_tag(file, tag):
             data = json.load(f)
 
         if "aliases" not in data:
-            console.print(f"[red]✗[/] Invalid export file")
+            console.print("[red]✗[/] Invalid export file")
             return
 
         imported = 0
@@ -1413,11 +1412,11 @@ def import_tag(file, tag):
         console.print(f"[red]✗[/] Failed to import: {e}")
 
 
-@tag.command()
+@tag.command("export")
 @click.argument("tag_name")
 @click.option("--file", "-f", type=click.Path(), help="Output file path")
 @click.option("--format", type=click.Choice(["json", "yaml"]), default="json", help="Export format")
-def export(tag_name, file, format):
+def export_tag(tag_name, file, format):
     """Export all aliases with a specific tag"""
     aliases = storage.list_all()
     tagged_aliases = [a for a in aliases if tag_name in a.tags]
@@ -1481,20 +1480,20 @@ def export_multi(tags, file, format, match_all):
         console.print(f"[red]✗[/] {message}")
 
 
-@tag.command()
-def stats():
+@tag.command("stats")
+def stats_tag():
     """Show comprehensive tag statistics"""
     porter = AliasPorter()
     stats = porter.get_tag_statistics()
 
-    console.print(f"[bold cyan]📊 Tag Statistics[/]")
+    console.print("[bold cyan]📊 Tag Statistics[/]")
     console.print(f"Total tags: {stats['total_tags']}")
     console.print(f"Total aliases: {stats['total_aliases']}")
     console.print(f"Tagged aliases: {stats['tagged_aliases']}")
     console.print(f"Untagged aliases: {stats['untagged_aliases']}")
 
     if stats["tag_counts"]:
-        console.print(f"\n[bold]Most Used Tags:[/]")
+        console.print("\n[bold]Most Used Tags:[/]")
         table = Table(show_header=True, header_style="bold magenta")
         table.add_column("Tag", style="cyan", width=20)
         table.add_column("Count", style="yellow", width=10)
@@ -1507,7 +1506,7 @@ def stats():
         console.print(table)
 
     if stats["tag_combinations"]:
-        console.print(f"\n[bold]Most Common Tag Combinations:[/]")
+        console.print("\n[bold]Most Common Tag Combinations:[/]")
         table = Table(show_header=True, header_style="bold magenta")
         table.add_column("Tags", style="cyan", width=30)
         table.add_column("Count", style="yellow", width=10)
@@ -1535,15 +1534,15 @@ def templates():
     pass
 
 
-@templates.command()
-def list():
+@templates.command("list")
+def list_templates():
     """List available templates"""
     template_manager = TemplateManager()
 
     # Show categories first
     categories = template_manager.get_categories()
     if categories:
-        console.print(f"[bold cyan]📋 Available Categories:[/]")
+        console.print("[bold cyan]📋 Available Categories:[/]")
         for category in categories:
             templates = template_manager.list_templates(category)
             console.print(f"  [bold]{category}[/] ({len(templates)} templates)")
@@ -1572,7 +1571,7 @@ def list():
         )
 
     console.print(table)
-    console.print(f"\n[dim]💡 Use 'alix templates add <template>' to import a template[/]")
+    console.print("\n[dim]💡 Use 'alix templates add <template>' to import a template[/]")
 
 
 @templates.command(name="add")
@@ -1629,7 +1628,7 @@ def add_template(template_name, aliases, dry_run):
 
     if success:
         console.print(f"[green]✔[/] {message}")
-        console.print(f"\n[dim]💡 Run 'alix apply' to add these to your shell config[/]")
+        console.print("\n[dim]💡 Run 'alix apply' to add these to your shell config[/]")
     else:
         console.print(f"[red]✗[/] {message}")
 
@@ -1664,7 +1663,7 @@ def add_category(category, aliases, dry_run):
         if alias_names:
             console.print(f"[dim]Filtered aliases: {len(alias_names)}[/]")
 
-        console.print(f"\n[bold]Templates in category:[/]")
+        console.print("\n[bold]Templates in category:[/]")
         for template in templates:
             console.print(f"  • [cyan]{template.name}[/] - {template.description} ({len(template.aliases)} aliases)")
         return
@@ -1674,7 +1673,7 @@ def add_category(category, aliases, dry_run):
 
     if success:
         console.print(f"[green]✔[/] {message}")
-        console.print(f"\n[dim]💡 Run 'alix apply' to add these to your shell config[/]")
+        console.print("\n[dim]💡 Run 'alix apply' to add these to your shell config[/]")
     else:
         console.print(f"[red]✗[/] {message}")
 
diff --git a/alix/clipboard.py b/alix/clipboard.py
index 9f925dc..ecece75 100644
--- a/alix/clipboard.py
+++ b/alix/clipboard.py
@@ -1,5 +1,5 @@
-import subprocess
 import platform
+import subprocess
 from abc import ABC, abstractmethod
 
 try:
diff --git a/alix/config.py b/alix/config.py
index 2239516..35ad6c4 100644
--- a/alix/config.py
+++ b/alix/config.py
@@ -1,6 +1,6 @@
 import json
 from pathlib import Path
-from typing import Dict, Any, Optional
+from typing import Any, Dict
 
 
 class Config:
diff --git a/alix/history_manager.py b/alix/history_manager.py
index 0af2237..18663b1 100644
--- a/alix/history_manager.py
+++ b/alix/history_manager.py
@@ -1,5 +1,4 @@
 import json
-from pathlib import Path
 from datetime import datetime
 from typing import List, Dict, Any, Tuple, Optional
 
diff --git a/alix/models.py b/alix/models.py
index a17c91d..7217864 100644
--- a/alix/models.py
+++ b/alix/models.py
@@ -2,8 +2,7 @@
 
 from dataclasses import dataclass, field
 from datetime import datetime
-from typing import Optional, List, Dict
-import json
+from typing import Dict, List, Optional
 
 # Test alias constants for safe testing
 TEST_ALIAS_NAME = "alix-test-echo"
@@ -13,28 +12,22 @@
 @dataclass
 class UsageRecord:
     """Represents a single usage event of an alias"""
+
     timestamp: datetime
     context: Optional[str] = None  # Additional context like working directory, shell session, etc.
 
     def to_dict(self) -> dict:
         """Convert usage record to dictionary for storage"""
-        return {
-            "timestamp": self.timestamp.isoformat(),
-            "context": self.context
-        }
+        return {"timestamp": self.timestamp.isoformat(), "context": self.context}
 
     @classmethod
     def from_dict(cls, data: dict) -> "UsageRecord":
         """Create usage record from dictionary"""
-        return cls(
-            timestamp=datetime.fromisoformat(data["timestamp"]),
-            context=data.get("context")
-        )
+        return cls(timestamp=datetime.fromisoformat(data["timestamp"]), context=data.get("context"))
 
 
 @dataclass
 class Alias:
-
     """Represents a shell alias with usage tracking"""
 
     name: str
@@ -60,8 +53,7 @@ def to_dict(self) -> dict:
             "shell": self.shell,
             "last_used": self.last_used.isoformat() if self.last_used else None,
             "usage_history": [record.to_dict() for record in self.usage_history],
-            "group": self.group
-
+            "group": self.group,
         }
 
     @classmethod
@@ -95,7 +87,7 @@ def get_usage_stats(self) -> Dict[str, any]:
                 "first_used": None,
                 "last_used": self.last_used,
                 "usage_frequency": 0,
-                "recent_usage": []
+                "recent_usage": [],
             }
 
         # Calculate usage frequency (uses per day since creation)
@@ -110,7 +102,7 @@ def get_usage_stats(self) -> Dict[str, any]:
             "first_used": self.usage_history[0].timestamp if self.usage_history else None,
             "last_used": self.last_used,
             "usage_frequency": usage_frequency,
-            "recent_usage": [record.to_dict() for record in recent_usage]
+            "recent_usage": [record.to_dict() for record in recent_usage],
         }
 
     def __str__(self) -> str:
diff --git a/alix/porter.py b/alix/porter.py
index 77a617c..8b802a4 100644
--- a/alix/porter.py
+++ b/alix/porter.py
@@ -1,8 +1,9 @@
 import json
-import yaml
-from pathlib import Path
 from datetime import datetime
-from typing import List, Dict, Any, Tuple
+from pathlib import Path
+from typing import Any, Dict, List, Tuple
+
+import yaml
 
 from alix.models import Alias
 from alix.storage import AliasStorage
@@ -100,7 +101,9 @@ def import_from_file(self, filepath: Path, merge: bool = False, tag_filter: str
         except Exception as e:
             return False, f"Import failed: {str(e)}"
 
-    def export_by_tags(self, tags: List[str], filepath: Path, format: str = "json", match_all: bool = False) -> Tuple[bool, str]:
+    def export_by_tags(
+        self, tags: List[str], filepath: Path, format: str = "json", match_all: bool = False
+    ) -> Tuple[bool, str]:
         """Export aliases that match any (or all) of the specified tags"""
         aliases = self.storage.list_all()
 
@@ -120,7 +123,7 @@ def export_by_tags(self, tags: List[str], filepath: Path, format: str = "json",
             "tags": tags,
             "match_all": match_all,
             "count": len(filtered_aliases),
-            "aliases": [alias.to_dict() for alias in filtered_aliases]
+            "aliases": [alias.to_dict() for alias in filtered_aliases],
         }
 
         try:
@@ -151,7 +154,7 @@ def get_tag_statistics(self) -> Dict[str, Any]:
             # Count tag combinations (pairs)
             if len(alias.tags) >= 2:
                 for i, tag1 in enumerate(alias.tags):
-                    for tag2 in alias.tags[i+1:]:
+                    for tag2 in alias.tags[i + 1 :]:
                         combo = tuple(sorted([tag1, tag2]))
                         tag_combinations[combo] = tag_combinations.get(combo, 0) + 1
 
@@ -161,5 +164,5 @@ def get_tag_statistics(self) -> Dict[str, Any]:
             "tagged_aliases": len([a for a in aliases if a.tags]),
             "untagged_aliases": len([a for a in aliases if not a.tags]),
             "tag_counts": dict(sorted(tag_counts.items(), key=lambda x: x[1], reverse=True)),
-            "tag_combinations": dict(sorted(tag_combinations.items(), key=lambda x: x[1], reverse=True))
+            "tag_combinations": dict(sorted(tag_combinations.items(), key=lambda x: x[1], reverse=True)),
         }
diff --git a/alix/render.py b/alix/render.py
index 930ff59..256eb0b 100644
--- a/alix/render.py
+++ b/alix/render.py
@@ -1,16 +1,16 @@
 import re
 from difflib import SequenceMatcher
-
 from typing import Any, List, Literal, Union
 
-from rich.table import Table
+from rich import box
 from rich.console import Console
+from rich.table import Table
 from rich.text import Text
-from rich import box
+
 
 class Render:
     def _split_keep_ws(self, s: str) -> List[Union[str, Any]]:
-        return re.split(r'(\s+)', s)
+        return re.split(r"(\s+)", s)
 
     def _word_level_text(self, left: str, right: str, side: Literal["left", "right"]) -> Text:
         """
@@ -52,12 +52,12 @@ def side_by_side_diff(self, old: str, new: str) -> None:
 
         table = Table(show_header=True, header_style="bold cyan", expand=True, box=box.ROUNDED)
         table.add_column("Current Config", overflow="fold", justify="center")
-        table.add_column("Purpose Config", overflow="fold", justify='center')
+        table.add_column("Purpose Config", overflow="fold", justify="center")
 
         for tag, i1, i2, j1, j2 in sm.get_opcodes():
             if tag == "equal":
                 for a_i, b_j in zip(range(i1, i2), range(j1, j2)):
-                    table.add_row(Text(old_lines[a_i], justify='left'), Text(new_lines[b_j], justify='left'))
+                    table.add_row(Text(old_lines[a_i], justify="left"), Text(new_lines[b_j], justify="left"))
             elif tag == "replace":
                 n = max(i2 - i1, j2 - j1)
                 for k in range(n):
@@ -68,7 +68,7 @@ def side_by_side_diff(self, old: str, new: str) -> None:
                     table.add_row(left_txt, right_txt)
             elif tag == "delete":
                 for a_i in range(i1, i2):
-                    table.add_row(Text(old_lines[a_i], style="bold red", justify='left'), Text(""))
+                    table.add_row(Text(old_lines[a_i], style="bold red", justify="left"), Text(""))
             elif tag == "insert":
                 for b_j in range(j1, j2):
                     table.add_row(Text(""), Text(new_lines[b_j], style="bold green", justify="left"))
@@ -91,4 +91,4 @@ def side_by_side_diff(self, old: str, new: str) -> None:
 # === ALIX MANAGED ALIASES END ===
 """
     render = Render()
-    render.side_by_side_diff(old, new)
\ No newline at end of file
+    render.side_by_side_diff(old, new)
diff --git a/alix/scanner.py b/alix/scanner.py
index 3416146..1b6e3b2 100644
--- a/alix/scanner.py
+++ b/alix/scanner.py
@@ -3,7 +3,7 @@
 import re
 import subprocess
 from pathlib import Path
-from typing import List, Dict
+from typing import Dict, List
 
 from alix.models import Alias
 from alix.shell_detector import ShellDetector, ShellType
diff --git a/alix/shell_detector.py b/alix/shell_detector.py
index f13c16a..9e19d90 100644
--- a/alix/shell_detector.py
+++ b/alix/shell_detector.py
@@ -1,12 +1,12 @@
 """Shell detection and configuration file handling"""
 
 import os
-import sys
-import subprocess
 import pwd
-from pathlib import Path
-from typing import Optional, Dict
+import subprocess
+import sys
 from enum import Enum
+from pathlib import Path
+from typing import Dict, Optional
 
 
 class ShellType(Enum):
@@ -45,9 +45,7 @@ def detect_current_shell(self) -> ShellType:
                 return ShellType.BASH
             elif "fish" in shell_env:
                 return ShellType.FISH
-            elif (
-                "sh" in shell_env and "bash" not in shell_env and "zsh" not in shell_env
-            ):
+            elif "sh" in shell_env and "bash" not in shell_env and "zsh" not in shell_env:
                 return ShellType.SH
 
         # Method 2: Check /etc/passwd for user's default shell (reliable fallback)
@@ -176,9 +174,7 @@ def _get_shell_hints_from_configs(self) -> Optional[ShellType]:
 
         return None
 
-    def find_config_files(
-        self, shell_type: Optional[ShellType] = None
-    ) -> Dict[str, Path]:
+    def find_config_files(self, shell_type: Optional[ShellType] = None) -> Dict[str, Path]:
         """Find existing configuration files for shell"""
         if shell_type is None:
             shell_type = self.detect_current_shell()
diff --git a/alix/shell_integrator.py b/alix/shell_integrator.py
index 98980e8..128487b 100644
--- a/alix/shell_integrator.py
+++ b/alix/shell_integrator.py
@@ -1,11 +1,12 @@
 import shutil
-from pathlib import Path
 from datetime import datetime
+from pathlib import Path
 from typing import Optional, Tuple
 
+from alix.models import Alias
 from alix.shell_detector import ShellDetector, ShellType
 from alix.storage import AliasStorage
-from alix.models import Alias, TEST_ALIAS_NAME
+
 
 class ShellIntegrator:
     """Apply aliases to shell configuration files"""
@@ -61,7 +62,7 @@ def export_aliases(self, shell_type: ShellType) -> str:
     def preview_aliases(self, target_file: Optional[Path] = None) -> Tuple[str, str]:
         """Get old and new config for dry-run"""
         # Read current config
-        if target_file == None:
+        if target_file is None:
             content = ""
         else:
             content = target_file.read_text()
@@ -73,7 +74,7 @@ def preview_aliases(self, target_file: Optional[Path] = None) -> Tuple[str, str]
         old_alix = ""
         if start_idx != -1 and end_idx != -1:
             old_alix = content[start_idx:]
-            content = content[:start_idx] + content[end_idx + len(self.ALIX_MARKER_END) + 1:]
+            content = content[:start_idx] + content[end_idx + len(self.ALIX_MARKER_END) + 1 :]
 
         # Add new aliases section
         aliases_section = f"\n{self.ALIX_MARKER_START}\n"
@@ -92,7 +93,7 @@ def apply_aliases(self, target_file: Optional[Path] = None) -> Tuple[bool, str]:
             return False, "No shell configuration file found"
 
         # Create backup
-        backup_path = self.backup_shell_config(target_file)
+        self.backup_shell_config(target_file)
 
         # Read current config
         content = target_file.read_text()
@@ -102,15 +103,11 @@ def apply_aliases(self, target_file: Optional[Path] = None) -> Tuple[bool, str]:
         end_idx = content.find(self.ALIX_MARKER_END)
 
         if start_idx != -1 and end_idx != -1:
-            content = (
-                content[:start_idx] + content[end_idx + len(self.ALIX_MARKER_END) + 1 :]
-            )
+            content = content[:start_idx] + content[end_idx + len(self.ALIX_MARKER_END) + 1 :]
 
         # Add new aliases section
         aliases_section = f"\n{self.ALIX_MARKER_START}\n"
-        aliases_section += (
-            f"# Generated by alix on {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\n"
-        )
+        aliases_section += f"# Generated by alix on {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\n"
         aliases_section += self.export_aliases(self.shell_type)
         aliases_section += f"\n{self.ALIX_MARKER_END}\n"
 
@@ -124,9 +121,7 @@ def apply_aliases(self, target_file: Optional[Path] = None) -> Tuple[bool, str]:
         )
 
     # NEW METHOD: apply_single_alias
-    def apply_single_alias(
-        self, alias: Alias, auto_reload: bool = True
-    ) -> Tuple[bool, str]:
+    def apply_single_alias(self, alias: Alias, auto_reload: bool = True) -> Tuple[bool, str]:
         """Apply a single alias immediately to the current shell session"""
         target_file = self.get_target_file()
 
@@ -168,29 +163,18 @@ def apply_single_alias(
     def reload_shell_config(self) -> bool:
         """Attempt to reload shell configuration"""
         import subprocess
-        import os
 
         target_file = self.get_target_file()
         if not target_file:
             return False
 
-        # Write a temporary script to source the config
-        temp_script = f"""
-#!/bin/bash
-source {target_file}
-alias {TEST_ALIAS_NAME} 2>/dev/null || true
-"""
-
         try:
             # For the current Python process environment
-            result = subprocess.run(
-                ["bash", "-c", f"source {target_file}"], capture_output=True, text=True
-            )
+            result = subprocess.run(["bash", "-c", f"source {target_file}"], capture_output=True, text=True)
             return result.returncode == 0
         except Exception:
             return False
 
-
     # NEW METHOD: install_completions
     def install_completions(self, script_content: str, shell_type: Optional[ShellType] = None) -> Tuple[bool, str]:
         """Install shell completion script and source it from the user's shell config.
@@ -228,11 +212,11 @@ def install_completions(self, script_content: str, shell_type: Optional[ShellTyp
             start_idx = current.find(self.ALIX_COMPLETION_MARKER_START)
             end_idx = current.find(self.ALIX_COMPLETION_MARKER_END)
             if start_idx != -1 and end_idx != -1:
-                current = current[:start_idx] + current[end_idx + len(self.ALIX_COMPLETION_MARKER_END) + 1:]
+                current = current[:start_idx] + current[end_idx + len(self.ALIX_COMPLETION_MARKER_END) + 1 :]
 
             completion_block = "\n" + self.ALIX_COMPLETION_MARKER_START + "\n"
             completion_block += f"# Generated by alix on {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\n"
-            completion_block += f"# Enable CLI tab completion for alix\n"
+            completion_block += "# Enable CLI tab completion for alix\n"
             completion_block += f"source {target_completion}\n"
             completion_block += self.ALIX_COMPLETION_MARKER_END + "\n"
 
@@ -242,4 +226,3 @@ def install_completions(self, script_content: str, shell_type: Optional[ShellTyp
             return True, f"Installed {suffix} completions to {target_completion} and sourced from {config_file}"
         except Exception as exc:
             return False, f"Failed to install completions: {exc}"
-
diff --git a/alix/shell_wrapper.py b/alix/shell_wrapper.py
index 1d9972a..96992f1 100644
--- a/alix/shell_wrapper.py
+++ b/alix/shell_wrapper.py
@@ -1,30 +1,28 @@
 """Shell wrapper functions for automatic usage tracking"""
 
 import os
-import subprocess
-import sys
-from pathlib import Path
-from typing import Optional, List
 from datetime import datetime
+from pathlib import Path
+from typing import Optional
 
 from alix.storage import AliasStorage
 
 
 class ShellWrapper:
     """Creates shell wrapper functions that track alias usage automatically"""
-    
+
     def __init__(self, storage_path: Optional[Path] = None):
         self.storage = AliasStorage(storage_path)
-    
+
     def generate_tracking_function(self, alias_name: str) -> str:
         """Generate a shell function that tracks usage and executes the alias"""
         alias = self.storage.get(alias_name)
         if not alias:
             return ""
-        
+
         # Get the current working directory for context
         cwd_context = os.getcwd()
-        
+
         # Create a tracking function that:
         # 1. Records the usage
         # 2. Executes the original command
@@ -32,24 +30,24 @@ def generate_tracking_function(self, alias_name: str) -> str:
 {alias_name}() {{
     # Track usage with alix
     alix track {alias_name} --context "cwd:{cwd_context}" >/dev/null 2>&1 &
-    
+
     # Execute the original command
     {alias.command} "$@"
 }}"""
         return tracking_function
-    
+
     def generate_all_tracking_functions(self) -> str:
         """Generate tracking functions for all aliases"""
         aliases = self.storage.list_all()
         functions = []
-        
+
         for alias in aliases:
             function = self.generate_tracking_function(alias.name)
             if function:
                 functions.append(function)
-        
+
         return "\n\n".join(functions)
-    
+
     def generate_shell_integration_script(self, shell_type: str = "bash") -> str:
         """Generate a complete shell integration script"""
         if shell_type == "bash":
@@ -60,7 +58,7 @@ def generate_shell_integration_script(self, shell_type: str = "bash") -> str:
             return self._generate_fish_integration()
         else:
             return self._generate_bash_integration()  # Default to bash
-    
+
     def _generate_bash_integration(self) -> str:
         """Generate bash integration script"""
         return f"""#!/bin/bash
@@ -71,7 +69,7 @@ def _generate_bash_integration(self) -> str:
 track_alias_usage() {{
     local alias_name="$1"
     local context="$2"
-    
+
     # Run tracking in background to avoid blocking
     alix track "$alias_name" --context "$context" >/dev/null 2>&1 &
 }}
@@ -85,7 +83,7 @@ def _generate_bash_integration(self) -> str:
 
 echo "Alix usage tracking enabled for {len(self.storage.list_all())} aliases"
 """
-    
+
     def _generate_zsh_integration(self) -> str:
         """Generate zsh integration script"""
         return f"""#!/bin/zsh
@@ -96,7 +94,7 @@ def _generate_zsh_integration(self) -> str:
 track_alias_usage() {{
     local alias_name="$1"
     local context="$2"
-    
+
     # Run tracking in background to avoid blocking
     alix track "$alias_name" --context "$context" >/dev/null 2>&1 &
 }}
@@ -109,20 +107,22 @@ def _generate_zsh_integration(self) -> str:
 
 echo "Alix usage tracking enabled for {len(self.storage.list_all())} aliases"
 """
-    
+
     def _generate_fish_integration(self) -> str:
         """Generate fish integration script"""
         # Fish has different syntax, so we need a different approach
         functions = []
         for alias in self.storage.list_all():
-            functions.append(f"""function {alias.name}
+            functions.append(
+                f"""function {alias.name}
     # Track usage
     alix track {alias.name} --context "cwd:{os.getcwd()}" >/dev/null 2>&1 &
-    
+
     # Execute command
     {alias.command} $argv
-end""")
-        
+end"""
+            )
+
         return f"""# Alix CLI Usage Tracking Integration for Fish
 # This script provides automatic usage tracking for aliases
 
@@ -130,38 +130,36 @@ def _generate_fish_integration(self) -> str:
 
 echo "Alix usage tracking enabled for {len(self.storage.list_all())} aliases"
 """
-    
+
     def install_tracking_integration(self, shell_config_path: Path, shell_type: str = "bash") -> bool:
         """Install tracking integration into shell config"""
         try:
             integration_script = self.generate_shell_integration_script(shell_type)
-            
+
             # Add integration to shell config
-            with open(shell_config_path, 'a') as f:
-                f.write(f"\n\n# Alix CLI Usage Tracking Integration\n")
+            with open(shell_config_path, "a") as f:
+                f.write("\n\n# Alix CLI Usage Tracking Integration\n")
                 f.write(f"# Added on {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\n")
                 f.write(integration_script)
-            
+
             return True
         except Exception:
             return False
-    
+
     def create_standalone_tracking_script(self, output_path: Path, shell_type: str = "bash") -> bool:
         """Create a standalone tracking script"""
         try:
             integration_script = self.generate_shell_integration_script(shell_type)
-            
+
             # Ensure the parent directory exists (only if it doesn't exist)
             if not output_path.parent.exists():
                 output_path.parent.mkdir(parents=True, exist_ok=True)
-            
-            with open(output_path, 'w') as f:
+
+            with open(output_path, "w") as f:
                 f.write(integration_script)
-            
+
             # Make it executable
             os.chmod(output_path, 0o755)
             return True
-        except Exception as e:
-            # For debugging purposes, you might want to log the exception
-            # print(f"Error creating standalone tracking script: {e}")
+        except Exception:
             return False
diff --git a/alix/storage.py b/alix/storage.py
index 61b20b6..45370f6 100644
--- a/alix/storage.py
+++ b/alix/storage.py
@@ -1,12 +1,12 @@
 import json
 import shutil
-from pathlib import Path
-from typing import List, Optional, Dict
 from datetime import datetime
+from pathlib import Path
+from typing import Dict, List, Optional
 
-from alix.models import Alias, TEST_ALIAS_NAME
-from alix.usage_tracker import UsageTracker
 from alix.history_manager import HistoryManager
+from alix.models import TEST_ALIAS_NAME, Alias
+from alix.usage_tracker import UsageTracker
 
 
 class AliasStorage:
@@ -60,10 +60,7 @@ def load(self) -> None:
             try:
                 with open(self.storage_path, "r") as f:
                     data = json.load(f)
-                    self.aliases = {
-                        name: Alias.from_dict(alias_data)
-                        for name, alias_data in data.items()
-                    }
+                    self.aliases = {name: Alias.from_dict(alias_data) for name, alias_data in data.items()}
             except (json.JSONDecodeError, Exception):
                 # If file is corrupted, start fresh but backup old file
                 backup_path = self.storage_path.with_suffix(".corrupted")
@@ -150,7 +147,7 @@ def get_usage_analytics(self) -> Dict:
             "recently_used": analytics.recently_used,
             "usage_trends": analytics.usage_trends,
             "average_usage_per_alias": analytics.average_usage_per_alias,
-            "most_productive_aliases": analytics.most_productive_aliases
+            "most_productive_aliases": analytics.most_productive_aliases,
         }
 
     def get_by_group(self, group_name: str) -> List[Alias]:
@@ -202,4 +199,3 @@ def get_tag_counts(self) -> Dict[str, int]:
             for tag in alias.tags:
                 tag_counts[tag] = tag_counts.get(tag, 0) + 1
         return tag_counts
-
diff --git a/alix/template_manager.py b/alix/template_manager.py
index 62f7d51..8cc9659 100644
--- a/alix/template_manager.py
+++ b/alix/template_manager.py
@@ -1,6 +1,6 @@
 import yaml
 from pathlib import Path
-from typing import List, Dict, Any, Optional
+from typing import List, Dict, Optional
 from dataclasses import dataclass
 
 from alix.models import Alias
@@ -10,6 +10,7 @@
 @dataclass
 class Template:
     """Represents a template with metadata and aliases"""
+
     name: str
     category: str
     description: str
@@ -72,7 +73,7 @@ def _load_templates(self) -> None:
                         name=alias_data["name"],
                         command=alias_data["command"],
                         description=alias_data.get("description", ""),
-                        tags=alias_data.get("tags", [])
+                        tags=alias_data.get("tags", []),
                     )
                     aliases.append(alias)
 
@@ -81,12 +82,12 @@ def _load_templates(self) -> None:
                     category=data.get("category", "general"),
                     description=data.get("description", ""),
                     aliases=aliases,
-                    version=data.get("version", "1.0")
+                    version=data.get("version", "1.0"),
                 )
 
                 self._templates[template_name] = template
 
-            except Exception as e:
+            except Exception:
                 # Skip malformed templates
                 continue
 
@@ -161,4 +162,4 @@ def import_by_category(self, category: str, alias_filter: Optional[List[str]] =
         if total_skipped > 0:
             msg += f" (skipped {total_skipped} existing)"
 
-        return True, msg
\ No newline at end of file
+        return True, msg
diff --git a/alix/tui.py b/alix/tui.py
index 3c8a97c..5e2991b 100644
--- a/alix/tui.py
+++ b/alix/tui.py
@@ -1,27 +1,18 @@
 import subprocess
+
+from rapidfuzz import fuzz
 from textual.app import App, ComposeResult
-from textual.containers import Container, Horizontal, Vertical, Center, VerticalScroll
-from textual.widgets import (
-    Header,
-    Footer,
-    DataTable,
-    Input,
-    Button,
-    Label,
-    Static,
-    Checkbox,
-)
 from textual.binding import Binding
-from textual.screen import Screen, ModalScreen
-from datetime import datetime
-from rapidfuzz import fuzz, process
+from textual.containers import Container, Horizontal, VerticalScroll
+from textual.screen import ModalScreen
+from textual.widgets import Button, Checkbox, DataTable, Footer, Input, Label, Static
 
 from alix import __version__
-from alix.storage import AliasStorage
-from alix.models import Alias
+from alix.clipboard import ClipboardManager
 from alix.config import Config
+from alix.models import Alias
 from alix.shell_integrator import ShellIntegrator  # NEW IMPORT
-from alix.clipboard import ClipboardManager
+from alix.storage import AliasStorage
 
 
 class AddAliasModal(ModalScreen[bool]):
@@ -133,7 +124,7 @@ def on_button_pressed(self, event: Button.Pressed) -> None:
             desc = self.query_one("#description", Input).value.strip()
             tags_input = self.query_one("#tags", Input).value.strip()
             force = self.query_one("#force", Checkbox).value
-            
+
             # Parse tags
             tags = []
             if tags_input:
@@ -153,7 +144,10 @@ def on_button_pressed(self, event: Button.Pressed) -> None:
                             "bash",
                             "-i",
                             "-c",
-                            f"(alias; declare -f) | /usr/bin/which --tty-only --read-alias --read-functions --show-tilde --show-dot {name}",
+                            (
+                                "(alias; declare -f) | /usr/bin/which --tty-only --read-alias "
+                                f"--read-functions --show-tilde --show-dot {name}"
+                            ),
                         ],
                         capture_output=True,
                         text=True,
@@ -162,8 +156,8 @@ def on_button_pressed(self, event: Button.Pressed) -> None:
                     if cmd.returncode == 0:
                         command_exists = True
                         msg = (
-                            "Alias/Command/Function already exists\nEnable Force Override if you want to override this alias\n"
-                            + cmd.stdout
+                            "Alias/Command/Function already exists\n"
+                            "Enable Force Override if you want to override this alias\n" + cmd.stdout
                         )
                 if command_exists and not force:
                     self.app.notify(
@@ -178,13 +172,9 @@ def on_button_pressed(self, event: Button.Pressed) -> None:
                         success, message = integrator.apply_single_alias(alias)
 
                         if success:
-                            self.app.notify(
-                                f"Created and applied '{name}'", severity="information"
-                            )
+                            self.app.notify(f"Created and applied '{name}'", severity="information")
                         else:
-                            self.app.notify(
-                                f"Created '{name}' (apply manually)", severity="warning"
-                            )
+                            self.app.notify(f"Created '{name}' (apply manually)", severity="warning")
 
                         self.dismiss(True)
                     else:
@@ -403,9 +393,7 @@ def compose(self) -> ComposeResult:
             yield Static("DELETE CONFIRMATION", id="modal-header")
 
             with Container(id="modal-body"):
-                yield Static(
-                    f"Delete alias '{self.alias_name}'?", classes="delete-text"
-                )
+                yield Static(f"Delete alias '{self.alias_name}'?", classes="delete-text")
                 yield Static("This action cannot be undone", classes="warning-text")
 
             with Horizontal(id="button-row"):
@@ -472,9 +460,7 @@ def compose(self) -> ComposeResult:
                 yield Static("e - Edit selected alias", classes="help-item")
                 yield Static("d - Delete selected alias", classes="help-item")
                 yield Static("c - Copy alias command", classes="help-item")
-                yield Static(
-                    "p - Apply all aliases to shell config", classes="help-item"
-                )
+                yield Static("p - Apply all aliases to shell config", classes="help-item")
 
                 yield Static("FILTERING", classes="help-category")
                 yield Static("g - Filter by group", classes="help-item")
@@ -609,9 +595,7 @@ class AliasManager(App):
     # MODIFIED: Added 'p' binding for apply all and 'f' for fuzzy search
     BINDINGS = [
         Binding("q", "quit", "Quit", show=True, priority=True),
-        Binding(
-            "c", "copy_alias", "Copy", show=True
-        ),  # copy the alias command to clipboard
+        Binding("c", "copy_alias", "Copy", show=True),  # copy the alias command to clipboard
         Binding("a", "add_alias", "Add", show=True),
         Binding("e", "edit_alias", "Edit", show=True),
         Binding("d", "delete_alias", "Delete", show=True),
@@ -635,7 +619,7 @@ def __init__(self):
         self.selected_alias = None
         self.fuzzy_search_enabled = False  # NEW: Fuzzy search toggle
         self._current_group_filter = None  # NEW: Group filter state
-        self._current_tag_filter = None    # NEW: Tag filter state
+        self._current_tag_filter = None  # NEW: Tag filter state
 
     def compose(self) -> ComposeResult:
         # Header
@@ -657,9 +641,7 @@ def compose(self) -> ComposeResult:
                     yield Button("Add New", variant="success", id="btn-add")
                     yield Button("Edit", variant="warning", id="btn-edit")
                     yield Button("Delete", variant="error", id="btn-delete")
-                    yield Button(
-                        "Apply All", variant="primary", id="btn-apply"
-                    )  # NEW BUTTON
+                    yield Button("Apply All", variant="primary", id="btn-apply")  # NEW BUTTON
                     yield Button("Refresh", variant="default", id="btn-refresh")
 
                 # Info panel
@@ -691,7 +673,7 @@ def refresh_table(self, search_term: str = "") -> None:
         aliases = sorted(self.storage.list_all(), key=lambda a: a.name)
 
         # Apply group filter
-        current_group_filter = getattr(self, '_current_group_filter', None)
+        current_group_filter = getattr(self, "_current_group_filter", None)
         if current_group_filter and current_group_filter not in ["All Groups"]:
             if current_group_filter == "Ungrouped":
                 aliases = [a for a in aliases if not a.group]
@@ -699,7 +681,7 @@ def refresh_table(self, search_term: str = "") -> None:
                 aliases = [a for a in aliases if a.group == current_group_filter]
 
         # Apply tag filter
-        current_tag_filter = getattr(self, '_current_tag_filter', None)
+        current_tag_filter = getattr(self, "_current_tag_filter", None)
         if current_tag_filter and current_tag_filter not in ["All Tags"]:
             if current_tag_filter == "Untagged":
                 aliases = [a for a in aliases if not a.tags]
@@ -712,18 +694,10 @@ def refresh_table(self, search_term: str = "") -> None:
                 results = []
                 for alias in aliases:
                     # Search across name, command, and description
-                    name_score = fuzz.partial_ratio(
-                        search_term.lower(), alias.name.lower()
-                    )
-                    cmd_score = fuzz.partial_ratio(
-                        search_term.lower(), alias.command.lower()
-                    )
+                    name_score = fuzz.partial_ratio(search_term.lower(), alias.name.lower())
+                    cmd_score = fuzz.partial_ratio(search_term.lower(), alias.command.lower())
                     desc_score = (
-                        fuzz.partial_ratio(
-                            search_term.lower(), alias.description.lower()
-                        )
-                        if alias.description
-                        else 0
+                        fuzz.partial_ratio(search_term.lower(), alias.description.lower()) if alias.description else 0
                     )
 
                     # Use the highest score
@@ -762,32 +736,27 @@ def refresh_table(self, search_term: str = "") -> None:
         self.update_status(len(aliases))
 
     def update_status(self, shown: int = None) -> None:
+
         status = self.query_one("#status-bar", Static)
         total = len(self.storage.list_all())
 
         # Add fuzzy search indicator
-        fuzzy_status = (
-            "[green]Fuzzy ON[/]" if self.fuzzy_search_enabled else "[dim]Fuzzy OFF[/]"
-        )
+        fuzzy_status = "[green]Fuzzy ON[/]" if self.fuzzy_search_enabled else "[dim]Fuzzy OFF[/]"
 
         # Add filter indicators
         filter_text = ""
-        current_group_filter = getattr(self, '_current_group_filter', None)
-        current_tag_filter = getattr(self, '_current_tag_filter', None)
-        
+        current_group_filter = getattr(self, "_current_group_filter", None)
+        current_tag_filter = getattr(self, "_current_tag_filter", None)
+
         if current_group_filter and current_group_filter != "All Groups":
             filter_text += f" | Group: {current_group_filter}"
         if current_tag_filter and current_tag_filter != "All Tags":
             filter_text += f" | Tag: {current_tag_filter}"
 
         if shown is not None:
-            status.update(
-                f"Showing {shown} of {total} aliases | {fuzzy_status}{filter_text} | Press 'p' to apply all"
-            )
+            status.update(f"Showing2 {shown} of {total} aliases | {fuzzy_status}{filter_text} | Press 'p' to apply all")
         else:
-            status.update(
-                f"Total: {total} aliases | {fuzzy_status}{filter_text} | Press 'p' to apply all"
-            )
+            status.update(f"Total2: {total} aliases | {fuzzy_status}{filter_text} | Press 'p' to apply all")
 
     def update_info_panel(self, alias: Alias) -> None:
         info = self.query_one("#info-content", Static)
@@ -800,7 +769,7 @@ def update_info_panel(self, alias: Alias) -> None:
 
         tags_text = Text(", ".join(alias.tags) if alias.tags else "None")
         group_text = Text(alias.group or "None")
-        
+
         info.update(
             Text.assemble(
                 ("Name: ", "bold"),
@@ -853,7 +822,7 @@ def action_copy_alias(self) -> None:
         try:
             clipboard.copy(alias_cmd)
             self.notify("Alias command copied to clipboard")
-        except:
+        except Exception:
             self.notify(f"Unable to copy. Command: {alias_cmd}")
 
     def action_edit_alias(self) -> None:
@@ -877,9 +846,7 @@ def callback(confirmed: bool):
                         self.refresh_table()
                         self.notify(f"Deleted '{self.selected_alias.name}'")
                         self.selected_alias = None
-                        self.query_one("#info-content", Static).update(
-                            "Select an alias"
-                        )
+                        self.query_one("#info-content", Static).update("Select an alias")
                         # Reapply all to remove deleted alias from shell
                         integrator = ShellIntegrator()
                         integrator.apply_aliases()
@@ -938,9 +905,7 @@ def action_apply_all(self) -> None:
         success, message = integrator.apply_aliases(target_file)
 
         if success:
-            self.notify(
-                f"Applied all aliases to {target_file.name}", severity="success"
-            )
+            self.notify(f"Applied all aliases to {target_file.name}", severity="success")
             self.update_status()
         else:
             self.notify(f"Failed: {message}", severity="error")
@@ -957,7 +922,7 @@ def on_button_pressed(self, event: Button.Pressed) -> None:
             self.action_apply_all()
         elif event.button.id == "btn-refresh":
             self.action_refresh()
-    
+
     def action_filter_by_group(self) -> None:
         # Always build group list from ALL aliases
         all_aliases = self.storage.list_all()
@@ -965,7 +930,7 @@ def action_filter_by_group(self) -> None:
         groups_list = ["All Groups"] + groups + ["Ungrouped"]
 
         # Find current filter and cycle to next
-        current_filter = getattr(self, '_current_group_filter', None)
+        current_filter = getattr(self, "_current_group_filter", None)
         try:
             idx = groups_list.index(current_filter) if current_filter in groups_list else 0
             next_idx = (idx + 1) % len(groups_list)
@@ -988,25 +953,25 @@ def action_filter_by_group(self) -> None:
         """Filter aliases by group"""
         aliases = self.storage.list_all()
         groups = set()
-        
+
         # Collect all unique groups
         for alias in aliases:
             if alias.group:
                 groups.add(alias.group)
-        
+
         if not groups:
             self.notify("No groups found. Create some aliases with groups first.", severity="warning")
             return
-        
+
         # Create a simple group selection dialog
         groups_list = sorted(list(groups))
         groups_list.insert(0, "All Groups")  # Add option to show all
-        groups_list.append("Ungrouped")      # Add option to show ungrouped
-        
+        groups_list.append("Ungrouped")  # Add option to show ungrouped
+
         # For now, we'll use a simple approach - cycle through groups
         # In a more advanced implementation, you could create a proper selection modal
-        current_filter = getattr(self, '_current_group_filter', None)
-        
+        current_filter = getattr(self, "_current_group_filter", None)
+
         if current_filter is None:
             # Start with first group
             selected_group = groups_list[0]
@@ -1018,9 +983,9 @@ def action_filter_by_group(self) -> None:
                 selected_group = groups_list[next_index]
             except ValueError:
                 selected_group = groups_list[0]
-        
+
         self._current_group_filter = selected_group
-        
+
         # Apply the filter
         if selected_group == "All Groups":
             self.notify("Showing all aliases", severity="information")
@@ -1034,32 +999,32 @@ def action_filter_by_tag(self) -> None:
         # Always build tag list from ALL aliases
         all_aliases = self.storage.list_all()
         tags = set()
-        
+
         # Collect all unique tags
         for alias in all_aliases:
             tags.update(alias.tags)
-        
+
         if not tags:
             self.notify("No tags found. Create some aliases with tags first.", severity="warning")
             return
-        
+
         # Create tag list with special options
         tags_list = ["All Tags"] + sorted(list(tags)) + ["Untagged"]
-        
+
         # Find current filter and cycle to next
-        current_filter = getattr(self, '_current_tag_filter', None)
+        current_filter = getattr(self, "_current_tag_filter", None)
         try:
             idx = tags_list.index(current_filter) if current_filter in tags_list else 0
             next_idx = (idx + 1) % len(tags_list)
         except ValueError:
             next_idx = 0
-        
+
         selected_tag = tags_list[next_idx]
         self._current_tag_filter = selected_tag
-        
+
         # Refresh table with new filter
         self.refresh_table()
-        
+
         # Notify user
         if selected_tag == "All Tags":
             self.notify("Showing all aliases", severity="information")
@@ -1067,17 +1032,3 @@ def action_filter_by_tag(self) -> None:
             self.notify("Showing untagged aliases", severity="information")
         else:
             self.notify(f"Showing aliases with tag: {selected_tag}", severity="information")
-
-    def update_status(self, shown: int = None) -> None:
-        status = self.query_one("#status-bar", Static)
-        total = len(self.storage.list_all())
-
-        current_filter = getattr(self, '_current_group_filter', None)
-        filter_text = ""
-        if current_filter and current_filter != "All Groups":
-            filter_text = f" | Filter: {current_filter}"
-
-        if shown is not None:
-            status.update(f"Showing {shown} of {total} aliases{filter_text} | Press 'g' to filter by group")
-        else:
-            status.update(f"Total: {total} aliases{filter_text} | Press 'g' to filter by group")
\ No newline at end of file
diff --git a/alix/usage_tracker.py b/alix/usage_tracker.py
index 8d3687f..697f5ce 100644
--- a/alix/usage_tracker.py
+++ b/alix/usage_tracker.py
@@ -1,18 +1,18 @@
 """Usage tracking functionality for aliases"""
 
-import os
 import json
+from dataclasses import dataclass
 from datetime import datetime, timedelta
 from pathlib import Path
 from typing import Dict, List, Optional, Tuple
-from dataclasses import dataclass
 
-from alix.models import Alias, UsageRecord
+from alix.models import Alias
 
 
 @dataclass
 class UsageAnalytics:
     """Analytics data for alias usage"""
+
     total_aliases: int
     total_uses: int
     most_used_alias: Optional[str]
@@ -26,7 +26,7 @@ class UsageAnalytics:
 
 class UsageTracker:
     """Handles tracking and analytics of alias usage"""
-    
+
     def __init__(self, storage_path: Optional[Path] = None):
         """Initialize usage tracker"""
         if storage_path:
@@ -35,29 +35,29 @@ def __init__(self, storage_path: Optional[Path] = None):
             self.tracking_dir = Path.home() / ".alix"
             self.tracking_file = self.tracking_dir / "usage_tracking.json"
             self.tracking_dir.mkdir(exist_ok=True)
-        
+
         self.tracking_data = self._load_tracking_data()
-    
+
     def _load_tracking_data(self) -> Dict:
         """Load tracking data from file"""
         if self.tracking_file.exists():
             try:
-                with open(self.tracking_file, 'r') as f:
+                with open(self.tracking_file, "r") as f:
                     return json.load(f)
             except (json.JSONDecodeError, Exception):
                 return {}
         return {}
-    
+
     def _save_tracking_data(self) -> None:
         """Save tracking data to file"""
-        with open(self.tracking_file, 'w') as f:
+        with open(self.tracking_file, "w") as f:
             json.dump(self.tracking_data, f, indent=2, default=str)
-    
+
     def track_alias_usage(self, alias_name: str, context: Optional[str] = None) -> None:
         """Track usage of an alias"""
         now = datetime.now()
         date_key = now.strftime("%Y-%m-%d")
-        
+
         # Initialize tracking data structure if needed
         if "daily_usage" not in self.tracking_data:
             self.tracking_data["daily_usage"] = {}
@@ -65,32 +65,28 @@ def track_alias_usage(self, alias_name: str, context: Optional[str] = None) -> N
             self.tracking_data["alias_usage"] = {}
         if "last_updated" not in self.tracking_data:
             self.tracking_data["last_updated"] = now.isoformat()
-        
+
         # Update daily usage
         if date_key not in self.tracking_data["daily_usage"]:
             self.tracking_data["daily_usage"][date_key] = 0
         self.tracking_data["daily_usage"][date_key] += 1
-        
+
         # Update alias-specific usage
         if alias_name not in self.tracking_data["alias_usage"]:
-            self.tracking_data["alias_usage"][alias_name] = {
-                "total_uses": 0,
-                "last_used": None,
-                "usage_dates": []
-            }
-        
+            self.tracking_data["alias_usage"][alias_name] = {"total_uses": 0, "last_used": None, "usage_dates": []}
+
         self.tracking_data["alias_usage"][alias_name]["total_uses"] += 1
         self.tracking_data["alias_usage"][alias_name]["last_used"] = now.isoformat()
-        
+
         # Add to usage dates (keep only last 30 days)
         usage_dates = self.tracking_data["alias_usage"][alias_name]["usage_dates"]
         usage_dates.append(now.isoformat())
         if len(usage_dates) > 30:
             usage_dates.pop(0)
-        
+
         self.tracking_data["last_updated"] = now.isoformat()
         self._save_tracking_data()
-    
+
     def get_usage_analytics(self, aliases: List[Alias]) -> UsageAnalytics:
         """Generate comprehensive usage analytics"""
         if not aliases:
@@ -103,34 +99,28 @@ def get_usage_analytics(self, aliases: List[Alias]) -> UsageAnalytics:
                 recently_used=[],
                 usage_trends={},
                 average_usage_per_alias=0.0,
-                most_productive_aliases=[]
+                most_productive_aliases=[],
             )
-        
+
         # Basic statistics
         total_uses = sum(alias.used_count for alias in aliases)
         most_used = max(aliases, key=lambda a: a.used_count) if aliases else None
         least_used = min(aliases, key=lambda a: a.used_count) if aliases else None
-        
+
         # Unused aliases (never used)
         unused_aliases = [alias.name for alias in aliases if alias.used_count == 0]
-        
+
         # Recently used (last 7 days)
         week_ago = datetime.now() - timedelta(days=7)
-        recently_used = [
-            alias.name for alias in aliases 
-            if alias.last_used and alias.last_used >= week_ago
-        ]
-        
+        recently_used = [alias.name for alias in aliases if alias.last_used and alias.last_used >= week_ago]
+
         # Usage trends (last 30 days)
         usage_trends = self.tracking_data.get("daily_usage", {})
-        
+
         # Most productive aliases (by characters saved)
-        most_productive = [
-            (alias.name, len(alias.command) - len(alias.name))
-            for alias in aliases
-        ]
+        most_productive = [(alias.name, len(alias.command) - len(alias.name)) for alias in aliases]
         most_productive.sort(key=lambda x: x[1], reverse=True)
-        
+
         return UsageAnalytics(
             total_aliases=len(aliases),
             total_uses=total_uses,
@@ -140,46 +130,41 @@ def get_usage_analytics(self, aliases: List[Alias]) -> UsageAnalytics:
             recently_used=recently_used,
             usage_trends=usage_trends,
             average_usage_per_alias=total_uses / len(aliases) if aliases else 0,
-            most_productive_aliases=most_productive[:10]
+            most_productive_aliases=most_productive[:10],
         )
-    
+
     def get_alias_usage_history(self, alias_name: str, days: int = 30) -> List[Dict]:
         """Get usage history for a specific alias"""
         alias_data = self.tracking_data.get("alias_usage", {}).get(alias_name, {})
         usage_dates = alias_data.get("usage_dates", [])
-        
+
         # Filter to last N days
         cutoff_date = datetime.now() - timedelta(days=days)
-        recent_usage = [
-            date for date in usage_dates
-            if datetime.fromisoformat(date) >= cutoff_date
-        ]
-        
+        recent_usage = [date for date in usage_dates if datetime.fromisoformat(date) >= cutoff_date]
+
         return [{"date": date, "count": 1} for date in recent_usage]
-    
+
     def cleanup_old_data(self, days_to_keep: int = 90) -> None:
         """Clean up old tracking data to prevent file bloat"""
         cutoff_date = datetime.now() - timedelta(days=days_to_keep)
         cutoff_str = cutoff_date.strftime("%Y-%m-%d")
-        
+
         # Clean daily usage data
         if "daily_usage" in self.tracking_data:
             self.tracking_data["daily_usage"] = {
-                date: count for date, count in self.tracking_data["daily_usage"].items()
-                if date >= cutoff_str
+                date: count for date, count in self.tracking_data["daily_usage"].items() if date >= cutoff_str
             }
-        
+
         # Clean alias usage data
         if "alias_usage" in self.tracking_data:
             for alias_name in self.tracking_data["alias_usage"]:
                 usage_dates = self.tracking_data["alias_usage"][alias_name].get("usage_dates", [])
                 self.tracking_data["alias_usage"][alias_name]["usage_dates"] = [
-                    date for date in usage_dates
-                    if datetime.fromisoformat(date) >= cutoff_date
+                    date for date in usage_dates if datetime.fromisoformat(date) >= cutoff_date
                 ]
-        
+
         self._save_tracking_data()
-    
+
     def export_analytics(self, output_file: Path) -> None:
         """Export analytics data to a file"""
         export_data = {
@@ -188,9 +173,9 @@ def export_analytics(self, output_file: Path) -> None:
             "summary": {
                 "total_days_tracked": len(self.tracking_data.get("daily_usage", {})),
                 "total_aliases_tracked": len(self.tracking_data.get("alias_usage", {})),
-                "last_updated": self.tracking_data.get("last_updated")
-            }
+                "last_updated": self.tracking_data.get("last_updated"),
+            },
         }
-        
-        with open(output_file, 'w') as f:
+
+        with open(output_file, "w") as f:
             json.dump(export_data, f, indent=2, default=str)
diff --git a/pyproject.toml b/pyproject.toml
index be86ce3..0962958 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -25,7 +25,7 @@ dev = [
     "pytest>=7.0.0",
     "pytest-cov>=4.0.0",
     "black>=23.0.0",
-    "flake8>=6.0.0",
+    "Flake8-pyproject",
     "freezegun>=1.5.5",
     "pytest-asyncio>=0.24.0",
 ]
@@ -46,4 +46,5 @@ target-version = ['py310', 'py311', 'py312', 'py313']
 
 [tool.flake8]
 max-line-length = 120
+ignore = "E203, W503"
 exclude = [".git", "__pycache__", "build", "dist", "*.egg-info", "venv", "alix-venv"]
diff --git a/tests/test_cli.py b/tests/test_cli.py
index ce4223c..884a0a7 100644
--- a/tests/test_cli.py
+++ b/tests/test_cli.py
@@ -20,17 +20,7 @@ def test_cli_add(mock_storage, mock_subprocess, mock_apply, alias):
     runner = CliRunner()
     result = runner.invoke(
         main,
-        [
-            "add",
-            "-n",
-            "alix-test-echo",
-            "-c",
-            "alix test working!",
-            "-d",
-            "alix test shortcut",
-            "--tags",
-            "a, b"
-        ],
+        ["add", "-n", "alix-test-echo", "-c", "alix test working!", "-d", "alix test shortcut", "--tags", "a, b"],
     )
 
     assert result.exit_code == 0
@@ -40,10 +30,7 @@ def test_cli_add(mock_storage, mock_subprocess, mock_apply, alias):
     mock_storage.add.assert_called_with(alias, record_history=True)
 
     assert "✔ Added alias: alix-test-echo = 'alix test working!'" in result.output
-    assert (
-        "💡 Alias 'alix-test-echo' is now available in new shell sessions"
-        in result.output
-    )
+    assert "💡 Alias 'alix-test-echo' is now available in new shell sessions" in result.output
     assert "For current session, run: source" in result.output
 
 
@@ -118,17 +105,7 @@ def test_cli_add__apply_failed(mock_storage, mock_apply, alias):
     runner = CliRunner()
     result = runner.invoke(
         main,
-        [
-            "add",
-            "-n",
-            "alix-test-echo",
-            "-c",
-            "alix test working!",
-            "-d",
-            "alix test shortcut",
-            "--tags",
-            "a, b"
-        ],
+        ["add", "-n", "alix-test-echo", "-c", "alix test working!", "-d", "alix test shortcut", "--tags", "a, b"],
     )
 
     assert result.exit_code == 0
@@ -136,10 +113,7 @@ def test_cli_add__apply_failed(mock_storage, mock_apply, alias):
     mock_apply.assert_called_with(alias)
 
     assert "Added alias: alix-test-echo = 'alix test working!'" in result.output
-    assert (
-        "⚠ Alias saved but not applied: No shell configuration file found"
-        in result.output
-    )
+    assert "⚠ Alias saved but not applied: No shell configuration file found" in result.output
     assert "   Run 'alix apply' to apply all aliases to shell" in result.output
 
     assert "✓ Applied alias 'alix-test-echo' to" not in result.output
@@ -166,7 +140,7 @@ def test_cli_add__no_apply(mock_storage, mock_apply, alias):
             "-d",
             "alix test shortcut",
             "--tags",
-            "a, b"
+            "a, b",
         ],
     )
 
@@ -177,7 +151,4 @@ def test_cli_add__no_apply(mock_storage, mock_apply, alias):
 
     assert "Added alias: alix-test-echo = 'alix test working!'" in result.output
     assert "✓ Applied alias 'alix-test-echo' to" not in result.output
-    assert (
-        "⚠ Alias saved but not applied: alix-test-echo = 'alix test working!'"
-        not in result.output
-    )
+    assert "⚠ Alias saved but not applied: alix-test-echo = 'alix test working!'" not in result.output
diff --git a/tests/test_fuzzy_search.py b/tests/test_fuzzy_search.py
index 5fafaac..390cac9 100644
--- a/tests/test_fuzzy_search.py
+++ b/tests/test_fuzzy_search.py
@@ -1,6 +1,5 @@
 """Test fuzzy search functionality"""
 
-import pytest
 from rapidfuzz import fuzz
 
 
diff --git a/tests/test_porter.py b/tests/test_porter.py
index a43f4c9..2e55e33 100644
--- a/tests/test_porter.py
+++ b/tests/test_porter.py
@@ -35,9 +35,7 @@ def test_export_to_file__json(mock_json, mock_exporter, porter_data):
         result = porter.export_to_file((Path("/tmp/aliases.json")))
 
     assert result == (True, "Exported 2 aliases to aliases.json")
-    mock_json.dump.assert_called_once_with(
-        porter_data, mocked_open(), indent=2, default=str
-    )
+    mock_json.dump.assert_called_once_with(porter_data, mocked_open(), indent=2, default=str)
 
 
 @patch.object(AliasPorter, "export_to_dict")
@@ -52,9 +50,7 @@ def test_export_to_file__yaml(mock_yaml, mock_exporter, porter_data):
         result = porter.export_to_file((Path("/tmp/aliases.json")), format="yaml")
 
     assert result == (True, "Exported 2 aliases to aliases.json")
-    mock_yaml.dump.assert_called_once_with(
-        porter_data, mocked_open(), default_flow_style=False, sort_keys=False
-    )
+    mock_yaml.dump.assert_called_once_with(porter_data, mocked_open(), default_flow_style=False, sort_keys=False)
 
 
 @patch.object(AliasPorter, "export_to_dict")
@@ -84,9 +80,7 @@ def test_import_from_file__json(mock_json, alias, porter_data):
     porter = AliasPorter()
     porter.storage = mock_storage
 
-    with patch("alix.porter.open", mocked_open), patch(
-        "pathlib.Path.exists", autospec=True
-    ) as mock_exists:
+    with patch("alix.porter.open", mocked_open), patch("pathlib.Path.exists", autospec=True) as mock_exists:
         mock_exists.return_value = True
 
         result = porter.import_from_file(Path("/tmp/alias.json"))
@@ -94,10 +88,7 @@ def test_import_from_file__json(mock_json, alias, porter_data):
     assert result == (True, "Imported 1 aliases")
     assert len(mock_storage.aliases) == 1
     assert mock_storage.aliases["alix-test-echo"] == alias
-    assert (
-        str(mock_storage.aliases["alix-test-echo"])
-        == "alix-test-echo='alix test working!'"
-    )
+    assert str(mock_storage.aliases["alix-test-echo"]) == "alix-test-echo='alix test working!'"
     mock_storage.save.assert_called_once()
 
 
@@ -111,9 +102,7 @@ def test_import_from_file__alias_exists_no_merge(mock_yaml, alias, porter_data):
     porter = AliasPorter()
     porter.storage = mock_storage
 
-    with patch("alix.porter.open", mocked_open), patch(
-        "pathlib.Path.exists", autospec=True
-    ) as mock_exists:
+    with patch("alix.porter.open", mocked_open), patch("pathlib.Path.exists", autospec=True) as mock_exists:
         mock_exists.return_value = True
 
         result = porter.import_from_file(Path("/tmp/alias.yaml"))
@@ -129,9 +118,7 @@ def test_import_from_file__not_found():
 
     porter = AliasPorter()
 
-    with patch("alix.porter.open", mocked_open), patch(
-        "pathlib.Path.exists", autospec=True
-    ) as mock_exists:
+    with patch("alix.porter.open", mocked_open), patch("pathlib.Path.exists", autospec=True) as mock_exists:
         mock_exists.return_value = False
 
         result = porter.import_from_file(Path("/tmp/alias.json"))
@@ -150,9 +137,7 @@ def test_import_from_file__no_aliases_in_file(mock_json):
     porter = AliasPorter()
     porter.storage = mock_storage
 
-    with patch("alix.porter.open", mocked_open), patch(
-        "pathlib.Path.exists", autospec=True
-    ) as mock_exists:
+    with patch("alix.porter.open", mocked_open), patch("pathlib.Path.exists", autospec=True) as mock_exists:
         mock_exists.return_value = True
 
         result = porter.import_from_file(Path("/tmp/alias.json"))
@@ -168,9 +153,7 @@ def test_import_from_file__failed():
 
     porter = AliasPorter()
 
-    with patch("alix.porter.open", mocked_open), patch(
-        "pathlib.Path.exists", autospec=True
-    ) as mock_exists:
+    with patch("alix.porter.open", mocked_open), patch("pathlib.Path.exists", autospec=True) as mock_exists:
         mock_exists.return_value = True
 
         result = porter.import_from_file(Path("/tmp/alias.json"))
diff --git a/tests/test_scanner.py b/tests/test_scanner.py
index e4f773c..462db0e 100644
--- a/tests/test_scanner.py
+++ b/tests/test_scanner.py
@@ -1,14 +1,13 @@
+from pathlib import Path
+from unittest.mock import Mock, patch
+
 from alix.scanner import AliasScanner
 from alix.shell_detector import ShellDetector, ShellType
-from unittest.mock import patch, Mock
-from pathlib import Path
 
 
 @patch.object(ShellDetector, "find_config_files")
 @patch.object(ShellDetector, "detect_current_shell")
-def test_scan_system(
-    mock_detect_current_shell, mock_find_config_files, shell_file_data
-):
+def test_scan_system(mock_detect_current_shell, mock_find_config_files, shell_file_data):
     mock_detect_current_shell.return_value = ShellType.ZSH
     mock_path = Mock(spec=Path)
     mock_path.name = ".zshrc"
@@ -42,9 +41,7 @@ def test_scan_system__no_aliases(mock_detect_current_shell, mock_find_config_fil
 
 @patch("alix.scanner.subprocess")
 @patch.object(ShellDetector, "detect_current_shell")
-def test_get_active_aliases(
-    mock_detect_current_shell, mock_subprocess, shell_file_data
-):
+def test_get_active_aliases(mock_detect_current_shell, mock_subprocess, shell_file_data):
     mock_detect_current_shell.return_value = ShellType.ZSH
     mock_stdout = f"{shell_file_data}\n{shell_file_data}"
     mock_subprocess.run.return_value.returncode = 0
diff --git a/tests/test_storage.py b/tests/test_storage.py
index cf678c2..29327db 100644
--- a/tests/test_storage.py
+++ b/tests/test_storage.py
@@ -1,5 +1,5 @@
 from pathlib import Path
-from unittest.mock import Mock, mock_open, patch, call
+from unittest.mock import Mock, call, mock_open, patch
 
 from freezegun import freeze_time
 
@@ -12,11 +12,7 @@
 def test_init__default_path(mock_mkdir, mock_load):
     AliasStorage()
 
-    mock_mkdir.assert_has_calls([
-        call(exist_ok=True),
-        call(exist_ok=True),
-        call(parents=True, exist_ok=True)
-    ])
+    mock_mkdir.assert_has_calls([call(exist_ok=True), call(exist_ok=True), call(parents=True, exist_ok=True)])
     mock_load.assert_called_once()
 
 
@@ -27,10 +23,7 @@ def test_init__custom_path(mock_mkdir, mock_load):
 
     AliasStorage(storage_path=expected_storage_path)
 
-    mock_mkdir.assert_has_calls([
-        call(exist_ok=True),
-        call(parents=True, exist_ok=True)
-    ])
+    mock_mkdir.assert_has_calls([call(exist_ok=True), call(parents=True, exist_ok=True)])
     mock_load.assert_called_once()
 
 
@@ -82,9 +75,7 @@ def test_load(storage_file_raw_data, alias):
     storage = AliasStorage()
 
     mocked_open = mock_open(read_data=storage_file_raw_data)
-    with patch("alix.storage.open", mocked_open), patch(
-        "pathlib.Path.exists", autospec=True
-    ) as mock_exists:
+    with patch("alix.storage.open", mocked_open), patch("pathlib.Path.exists", autospec=True) as mock_exists:
         mock_exists.return_value = True
 
         storage.load()
@@ -100,9 +91,11 @@ def test_load__corrupted_file():
 
     storage = AliasStorage()
 
-    with patch("alix.storage.open", mocked_open), patch(
-        "pathlib.Path.exists", autospec=True
-    ) as mock_exists, patch("pathlib.Path.rename", autospec=True) as mock_rename:
+    with (
+        patch("alix.storage.open", mocked_open),
+        patch("pathlib.Path.exists", autospec=True) as mock_exists,
+        patch("pathlib.Path.rename", autospec=True) as mock_rename,
+    ):
         mock_exists.return_value = True
 
         storage.load()
@@ -128,9 +121,7 @@ def test_add(mock_json, alias, storage_file_data):
     assert result is True
     assert storage.aliases["alix-test-echo"] == alias
     mock_backup.assert_called_once()
-    mock_json.dump.assert_called_once_with(
-        storage_file_data, mocked_open(), indent=2, default=str
-    )
+    mock_json.dump.assert_called_once_with(storage_file_data, mocked_open(), indent=2, default=str)
 
 
 @patch("alix.storage.json")
diff --git a/tests/test_tui.py b/tests/test_tui.py
index f02b760..47614f4 100644
--- a/tests/test_tui.py
+++ b/tests/test_tui.py
@@ -31,9 +31,7 @@ async def test_add_alias(mock_storage, mock_notify, mock_apply, alias_min):
 
         await pilot.pause()  # Wait for async operations to complete
 
-        mock_notify.assert_any_call(
-            "Created and applied 'alix-test-echo'", severity="information"
-        )
+        mock_notify.assert_any_call("Created and applied 'alix-test-echo'", severity="information")
         mock_notify.assert_any_call("Alias added and applied successfully")
         mock_storage.return_value.add.assert_called_once_with(alias_min)
         mock_apply.assert_called_once_with(alias_min)
diff --git a/tests/test_undo_redo.py b/tests/test_undo_redo.py
index 271ab45..c029d91 100644
--- a/tests/test_undo_redo.py
+++ b/tests/test_undo_redo.py
@@ -1,9 +1,10 @@
-import pytest
 from datetime import datetime
 
+import pytest
+
+from alix.history_manager import MAX_HISTORY
 from alix.models import Alias
 from alix.storage import AliasStorage
-from alix.history_manager import MAX_HISTORY
 
 
 @pytest.fixture
@@ -19,18 +20,18 @@ def temp_storage(tmp_path):
 
 def test_add_undo_redo(temp_storage):
     alias = Alias(name="test", command="echo hello")
-    
+
     # Add alias
     assert temp_storage.add(alias, record_history=True)
     assert len(temp_storage.list_all()) == 1
     assert len(temp_storage.history.list_undo()) == 1
-    
+
     # Undo
     msg = temp_storage.history.perform_undo(temp_storage)
     assert "Undid add" in msg
     assert len(temp_storage.list_all()) == 0
     assert len(temp_storage.history.list_redo()) == 1
-    
+
     # Redo
     msg = temp_storage.history.perform_redo(temp_storage)
     assert "Redid add" in msg
@@ -40,18 +41,18 @@ def test_add_undo_redo(temp_storage):
 def test_remove_undo_redo(temp_storage):
     alias = Alias(name="test", command="echo hi")
     temp_storage.add(alias, record_history=True)
-    
+
     # Remove alias
     assert temp_storage.remove(alias.name, record_history=True)
     assert len(temp_storage.list_all()) == 0
     assert len(temp_storage.history.list_undo()) == 2  # add + remove
-    
+
     # Undo remove
     msg = temp_storage.history.perform_undo(temp_storage)
     assert "Undid remove" in msg
     assert len(temp_storage.list_all()) == 1
     assert len(temp_storage.history.list_redo()) == 1
-    
+
     # Redo remove
     msg = temp_storage.history.perform_redo(temp_storage)
     assert "Redid remove" in msg
@@ -63,24 +64,24 @@ def test_remove_group_undo_redo(temp_storage):
     alias2 = Alias(name="test2", command="echo two", group="test_group")
     temp_storage.add(alias1, record_history=True)
     temp_storage.add(alias2, record_history=True)
-    
+
     # Remove group
     removed_count = temp_storage.remove_group("test_group")
     assert removed_count == 2
     assert len(temp_storage.list_all()) == 0
     assert len(temp_storage.history.list_undo()) == 3  # add1 + add2 + remove_group
-    
+
     # Undo remove group
     msg = temp_storage.history.perform_undo(temp_storage)
     assert "Undid remove_group" in msg
     assert len(temp_storage.list_all()) == 2
     assert len(temp_storage.history.list_redo()) == 1
-    
+
     # Undo add2
     msg = temp_storage.history.perform_undo(temp_storage)
     assert "Undid add" in msg
     assert len(temp_storage.list_all()) == 1
-    
+
     # Redo add2
     msg = temp_storage.history.perform_redo(temp_storage)
     assert "Redid add" in msg
@@ -104,7 +105,7 @@ def test_max_history_trimming(temp_storage):
     for i in range(MAX_HISTORY + 1):
         alias = Alias(name=f"test{i}", command=f"echo {i}")
         temp_storage.add(alias, record_history=True)
-    
+
     assert len(temp_storage.history.list_undo()) == MAX_HISTORY
     # Oldest should be trimmed (last one is most recent)
     assert temp_storage.history.list_undo()[-1]["aliases"][0]["name"] == f"test{MAX_HISTORY}"
@@ -114,7 +115,7 @@ def test_corrupted_history_file(tmp_path):
     # Create a temporary history file with invalid JSON
     history_path = tmp_path / "history.json"
     history_path.parent.mkdir(exist_ok=True)
-    with open(history_path, 'w') as f:
+    with open(history_path, "w") as f:
         f.write("{invalid json")
 
     # Create storage with the corrupted history file
@@ -133,15 +134,15 @@ def test_partial_failures(temp_storage):
     # Add valid alias
     alias_valid = Alias(name="valid", command="echo ok")
     temp_storage.add(alias_valid, record_history=True)
-    
+
     # Simulate corrupted alias data in history
     corrupted_op = {
         "type": "add",
         "aliases": [{"invalid": "data"}],  # Missing name
-        "timestamp": datetime.now().isoformat()
+        "timestamp": datetime.now().isoformat(),
     }
     temp_storage.history.push(corrupted_op)
-    
+
     # Undo should handle gracefully
     msg = temp_storage.history.perform_undo(temp_storage)
     assert "skipped" in msg.lower()
diff --git a/tests/test_usage_tracking.py b/tests/test_usage_tracking.py
index 57d7f8b..cecc7f9 100644
--- a/tests/test_usage_tracking.py
+++ b/tests/test_usage_tracking.py
@@ -4,95 +4,92 @@
 import tempfile
 from datetime import datetime, timedelta
 from pathlib import Path
-from unittest.mock import patch, MagicMock
+from unittest.mock import patch
 
 import pytest
 
 from alix.models import Alias, UsageRecord
-from alix.storage import AliasStorage
-from alix.usage_tracker import UsageTracker, UsageAnalytics
 from alix.shell_wrapper import ShellWrapper
+from alix.storage import AliasStorage
+from alix.usage_tracker import UsageAnalytics, UsageTracker
 
 
 class TestUsageRecord:
     """Test UsageRecord model"""
-    
+
     def test_usage_record_creation(self):
         """Test creating a usage record"""
         timestamp = datetime.now()
         record = UsageRecord(timestamp=timestamp, context="test context")
-        
+
         assert record.timestamp == timestamp
         assert record.context == "test context"
-    
+
     def test_usage_record_to_dict(self):
         """Test converting usage record to dictionary"""
         timestamp = datetime.now()
         record = UsageRecord(timestamp=timestamp, context="test context")
-        
+
         data = record.to_dict()
-        
+
         assert data["timestamp"] == timestamp.isoformat()
         assert data["context"] == "test context"
-    
+
     def test_usage_record_from_dict(self):
         """Test creating usage record from dictionary"""
         timestamp = datetime.now()
-        data = {
-            "timestamp": timestamp.isoformat(),
-            "context": "test context"
-        }
-        
+        data = {"timestamp": timestamp.isoformat(), "context": "test context"}
+
         record = UsageRecord.from_dict(data)
-        
+
         assert record.timestamp == timestamp
         assert record.context == "test context"
 
 
 class TestAliasUsageTracking:
     """Test alias usage tracking functionality"""
-    
+
     def test_alias_record_usage(self):
         """Test recording usage for an alias"""
         alias = Alias(name="test", command="echo hello")
         initial_count = alias.used_count
-        
+
         alias.record_usage("test context")
-        
+
         assert alias.used_count == initial_count + 1
         assert alias.last_used is not None
         assert len(alias.usage_history) == 1
         assert alias.usage_history[0].context == "test context"
-    
+
     def test_alias_usage_stats(self):
         """Test getting usage statistics for an alias"""
         alias = Alias(name="test", command="echo hello")
-        
+
         # Test with no usage
         stats = alias.get_usage_stats()
         assert stats["total_uses"] == 0
         assert stats["first_used"] is None
         assert stats["last_used"] is None
         assert stats["usage_frequency"] == 0
-        
+
         # Test with usage
         alias.record_usage()
         alias.record_usage()
-        
+
         stats = alias.get_usage_stats()
         assert stats["total_uses"] == 2
         assert stats["first_used"] is not None
         assert stats["last_used"] is not None
         assert stats["usage_frequency"] > 0
-    
+
     def test_alias_usage_history_limit(self):
         """Test that usage history is limited to prevent bloat"""
         alias = Alias(name="test", command="echo hello")
-        
+
         # Record more than 100 uses
         for i in range(150):
             alias.record_usage()
-        
+
         # Should only keep last 100 records
         assert len(alias.usage_history) == 100
         assert alias.used_count == 150
@@ -100,78 +97,78 @@ def test_alias_usage_history_limit(self):
 
 class TestUsageTracker:
     """Test UsageTracker functionality"""
-    
+
     @pytest.fixture
     def temp_dir(self):
         """Create temporary directory for testing"""
         with tempfile.TemporaryDirectory() as temp_dir:
             yield Path(temp_dir)
-    
+
     @pytest.fixture
     def usage_tracker(self, temp_dir):
         """Create UsageTracker instance for testing"""
         return UsageTracker(temp_dir)
-    
+
     def test_track_alias_usage(self, usage_tracker):
         """Test tracking alias usage"""
         usage_tracker.track_alias_usage("test_alias", "test context")
-        
+
         assert "test_alias" in usage_tracker.tracking_data["alias_usage"]
         assert usage_tracker.tracking_data["alias_usage"]["test_alias"]["total_uses"] == 1
         assert usage_tracker.tracking_data["alias_usage"]["test_alias"]["last_used"] is not None
-    
+
     def test_get_usage_analytics(self, usage_tracker):
         """Test getting usage analytics"""
         # Create test aliases
         aliases = [
             Alias(name="alias1", command="echo hello", used_count=5),
             Alias(name="alias2", command="echo world", used_count=0),
-            Alias(name="alias3", command="echo test", used_count=10)
+            Alias(name="alias3", command="echo test", used_count=10),
         ]
-        
+
         analytics = usage_tracker.get_usage_analytics(aliases)
-        
+
         assert analytics.total_aliases == 3
         assert analytics.total_uses == 15
         assert analytics.most_used_alias == "alias3"
         assert analytics.least_used_alias == "alias2"
         assert "alias2" in analytics.unused_aliases
         assert analytics.average_usage_per_alias == 5.0
-    
+
     def test_get_alias_usage_history(self, usage_tracker):
         """Test getting usage history for a specific alias"""
         # Track some usage
         usage_tracker.track_alias_usage("test_alias")
         usage_tracker.track_alias_usage("test_alias")
-        
+
         history = usage_tracker.get_alias_usage_history("test_alias", days=30)
-        
+
         assert len(history) == 2
         assert all("date" in record for record in history)
-    
+
     def test_cleanup_old_data(self, usage_tracker):
         """Test cleaning up old tracking data"""
         # Add some old data
         old_date = (datetime.now() - timedelta(days=100)).strftime("%Y-%m-%d")
         usage_tracker.tracking_data["daily_usage"] = {old_date: 5}
-        
+
         usage_tracker.cleanup_old_data(days_to_keep=30)
-        
+
         assert old_date not in usage_tracker.tracking_data["daily_usage"]
-    
+
     def test_export_analytics(self, usage_tracker, temp_dir):
         """Test exporting analytics data"""
         # Add some tracking data
         usage_tracker.track_alias_usage("test_alias")
-        
+
         output_file = temp_dir / "analytics.json"
         usage_tracker.export_analytics(output_file)
-        
+
         assert output_file.exists()
-        
-        with open(output_file, 'r') as f:
+
+        with open(output_file, "r") as f:
             data = json.load(f)
-        
+
         assert "exported_at" in data
         assert "tracking_data" in data
         assert "summary" in data
@@ -179,7 +176,7 @@ def test_export_analytics(self, usage_tracker, temp_dir):
     def test_initialization_without_storage_path(self, temp_dir):
         """Test initialization without providing storage_path"""
         # Mock the home directory to use temp_dir for this test
-        with patch('pathlib.Path.home', return_value=temp_dir):
+        with patch("pathlib.Path.home", return_value=temp_dir):
             # Create a UsageTracker without providing storage_path
             # This should use the default path and create the directory
             usage_tracker = UsageTracker()
@@ -239,10 +236,7 @@ def test_cleanup_old_data_daily_usage(self, usage_tracker):
         old_date = (datetime.now() - timedelta(days=100)).strftime("%Y-%m-%d")
         new_date = (datetime.now() - timedelta(days=10)).strftime("%Y-%m-%d")
 
-        usage_tracker.tracking_data["daily_usage"] = {
-            old_date: 5,
-            new_date: 3
-        }
+        usage_tracker.tracking_data["daily_usage"] = {old_date: 5, new_date: 3}
 
         # Clean up data older than 30 days
         usage_tracker.cleanup_old_data(days_to_keep=30)
@@ -260,11 +254,7 @@ def test_cleanup_old_data_alias_usage(self, usage_tracker):
 
         alias_name = "test_alias"
         usage_tracker.tracking_data["alias_usage"] = {
-            alias_name: {
-                "total_uses": 2,
-                "last_used": new_date,
-                "usage_dates": [old_date, new_date]
-            }
+            alias_name: {"total_uses": 2, "last_used": new_date, "usage_dates": [old_date, new_date]}
         }
 
         # Clean up data older than 30 days
@@ -279,47 +269,47 @@ def test_cleanup_old_data_alias_usage(self, usage_tracker):
 
 class TestAliasStorageIntegration:
     """Test integration of usage tracking with AliasStorage"""
-    
+
     @pytest.fixture
     def temp_dir(self):
         """Create temporary directory for testing"""
         with tempfile.TemporaryDirectory() as temp_dir:
             yield Path(temp_dir)
-    
+
     @pytest.fixture
     def storage(self, temp_dir):
         """Create AliasStorage instance for testing"""
         return AliasStorage(temp_dir / "aliases.json")
-    
+
     def test_track_usage_integration(self, storage):
         """Test tracking usage through storage"""
         # Add an alias
         alias = Alias(name="test", command="echo hello")
         storage.add(alias)
-        
+
         # Track usage
         storage.track_usage("test", "test context")
-        
+
         # Check that usage was recorded
         updated_alias = storage.get("test")
         assert updated_alias.used_count == 1
         assert updated_alias.last_used is not None
         assert len(updated_alias.usage_history) == 1
-    
+
     def test_get_usage_analytics(self, storage):
         """Test getting usage analytics through storage"""
         # Add some aliases with different usage patterns
         aliases = [
             Alias(name="alias1", command="echo hello", used_count=5),
             Alias(name="alias2", command="echo world", used_count=0),
-            Alias(name="alias3", command="echo test", used_count=10)
+            Alias(name="alias3", command="echo test", used_count=10),
         ]
-        
+
         for alias in aliases:
             storage.add(alias)
-        
+
         analytics = storage.get_usage_analytics()
-        
+
         assert analytics["total_aliases"] == 3
         assert analytics["total_uses"] == 15
         assert analytics["most_used_alias"] == "alias3"
@@ -329,13 +319,14 @@ def test_get_usage_analytics(self, storage):
 
 class TestShellWrapper:
     """Test ShellWrapper functionality"""
-    
+
     @pytest.fixture
     def temp_dir(self):
         """Create temporary directory for testing"""
-        import tempfile
-        import shutil
         import os
+        import shutil
+        import tempfile
+
         # Use a unique name to avoid conflicts
         temp_dir = os.path.join(tempfile.gettempdir(), f"alix_test_{os.getpid()}_{id(self)}")
         try:
@@ -346,67 +337,64 @@ def temp_dir(self):
             try:
                 if os.path.exists(temp_dir):
                     shutil.rmtree(temp_dir, ignore_errors=True)
-            except:
+            except Exception:
                 pass
-    
+
     @pytest.fixture
     def wrapper(self, temp_dir):
         """Create ShellWrapper instance for testing"""
         # Use a specific file path within the temp directory
         storage_file = temp_dir / "aliases.json"
         return ShellWrapper(storage_file)
-    
+
     def test_generate_tracking_function(self, wrapper, temp_dir):
         """Test generating tracking function for an alias"""
         # Add an alias to the wrapper's storage
         alias = Alias(name="test", command="echo hello")
         wrapper.storage.add(alias)
-        
+
         function = wrapper.generate_tracking_function("test")
-        
+
         assert "test()" in function
         assert "echo hello" in function
         assert "alix track" in function
-    
+
     def test_generate_all_tracking_functions(self, wrapper, temp_dir):
         """Test generating tracking functions for all aliases"""
         # Add some aliases to the wrapper's storage
-        aliases = [
-            Alias(name="alias1", command="echo hello"),
-            Alias(name="alias2", command="echo world")
-        ]
-        
+        aliases = [Alias(name="alias1", command="echo hello"), Alias(name="alias2", command="echo world")]
+
         for alias in aliases:
             wrapper.storage.add(alias)
-        
+
         functions = wrapper.generate_all_tracking_functions()
-        
+
         assert "alias1()" in functions
         assert "alias2()" in functions
         assert "echo hello" in functions
         assert "echo world" in functions
-    
+
     def test_generate_shell_integration_script(self, wrapper, temp_dir):
         """Test generating shell integration script"""
         # Add an alias to the wrapper's storage
         alias = Alias(name="test", command="echo hello")
         wrapper.storage.add(alias)
-        
+
         script = wrapper.generate_shell_integration_script("bash")
-        
+
         assert "#!/bin/bash" in script
         assert "track_alias_usage" in script
         assert "test()" in script
-    
+
     def test_create_standalone_tracking_script(self, wrapper, temp_dir):
         """Test creating standalone tracking script"""
         # Add an alias to the wrapper's storage
         alias = Alias(name="test", command="echo hello")
         wrapper.storage.add(alias)
-        
+
         output_path = temp_dir / "tracking.sh"
         success = wrapper.create_standalone_tracking_script(output_path, "bash")
-        
+
         assert success
         assert output_path.exists()
         assert output_path.stat().st_mode & 0o755  # Check executable permissions
@@ -414,7 +402,7 @@ def test_create_standalone_tracking_script(self, wrapper, temp_dir):
 
 class TestUsageAnalytics:
     """Test UsageAnalytics data class"""
-    
+
     def test_usage_analytics_creation(self):
         """Test creating UsageAnalytics instance"""
         analytics = UsageAnalytics(
@@ -426,9 +414,9 @@ def test_usage_analytics_creation(self):
             recently_used=["test"],
             usage_trends={"2023-01-01": 5},
             average_usage_per_alias=5.0,
-            most_productive_aliases=[("test", 10)]
+            most_productive_aliases=[("test", 10)],
         )
-        
+
         assert analytics.total_aliases == 10
         assert analytics.total_uses == 50
         assert analytics.most_used_alias == "test"
@@ -442,36 +430,36 @@ def test_usage_analytics_creation(self):
 
 class TestIntegration:
     """Integration tests for the complete usage tracking system"""
-    
+
     @pytest.fixture
     def temp_dir(self):
         """Create temporary directory for testing"""
         with tempfile.TemporaryDirectory() as temp_dir:
             yield Path(temp_dir)
-    
+
     def test_complete_usage_tracking_workflow(self, temp_dir):
         """Test complete workflow from alias creation to analytics"""
         # Create storage
         storage = AliasStorage(temp_dir / "aliases.json")
-        
+
         # Add aliases
         aliases = [
             Alias(name="alias1", command="echo hello"),
             Alias(name="alias2", command="echo world"),
-            Alias(name="alias3", command="echo test")
+            Alias(name="alias3", command="echo test"),
         ]
-        
+
         for alias in aliases:
             storage.add(alias)
-        
+
         # Track usage
         storage.track_usage("alias1", "context1")
         storage.track_usage("alias1", "context2")
         storage.track_usage("alias3", "context3")
-        
+
         # Get analytics
         analytics = storage.get_usage_analytics()
-        
+
         # Verify results
         assert analytics["total_aliases"] == 3
         assert analytics["total_uses"] == 3
@@ -480,7 +468,7 @@ def test_complete_usage_tracking_workflow(self, temp_dir):
         assert "alias2" in analytics["unused_aliases"]
         assert "alias1" in analytics["recently_used"]
         assert "alias3" in analytics["recently_used"]
-    
+
     def test_persistence_across_sessions(self, temp_dir):
         """Test that usage tracking persists across storage sessions"""
         # First session: create storage and track usage
@@ -488,11 +476,11 @@ def test_persistence_across_sessions(self, temp_dir):
         alias = Alias(name="test", command="echo hello")
         storage1.add(alias)
         storage1.track_usage("test", "context1")
-        
+
         # Second session: load storage and verify data
         storage2 = AliasStorage(temp_dir / "aliases.json")
         loaded_alias = storage2.get("test")
-        
+
         assert loaded_alias.used_count == 1
         assert loaded_alias.last_used is not None
         assert len(loaded_alias.usage_history) == 1

From 809db6e7fa1d451c65c9e3ce5b5f640aea1599f9 Mon Sep 17 00:00:00 2001
From: Andrew McIntosh <nacho.vonkickbutt@gmail.com>
Date: Sun, 12 Oct 2025 11:06:25 -0400
Subject: [PATCH 2/3] refactor: Fix redefinition in tui.py

Running flake8 detected two definitions of `update_status` in `tui.py`.
I initially removed the second, but since it redefined the method, I
should have removed the first (which appeared to have debug messaging).
This fixes that.
---
 Makefile    |  4 ++++
 alix/tui.py | 37 ++++++++++++++-----------------------
 2 files changed, 18 insertions(+), 23 deletions(-)

diff --git a/Makefile b/Makefile
index 7f20cac..0183d74 100644
--- a/Makefile
+++ b/Makefile
@@ -17,6 +17,10 @@ install: venv  ## Install alix in production mode
 dev-install: venv  ## Install alix with dev dependencies
 	$(PIP) install -e ".[dev]"
 
+black: dev-install  ## Run black
+	$(VENV)/bin/black alix
+	$(VENV)/bin/black tests
+
 check-style: dev-install  ## Run style checks
 	$(VENV)/bin/flake8 alix --count --show-source --statistics
 	$(VENV)/bin/flake8 tests --count --show-source --statistics
diff --git a/alix/tui.py b/alix/tui.py
index 5e2991b..32770f0 100644
--- a/alix/tui.py
+++ b/alix/tui.py
@@ -735,29 +735,6 @@ def refresh_table(self, search_term: str = "") -> None:
 
         self.update_status(len(aliases))
 
-    def update_status(self, shown: int = None) -> None:
-
-        status = self.query_one("#status-bar", Static)
-        total = len(self.storage.list_all())
-
-        # Add fuzzy search indicator
-        fuzzy_status = "[green]Fuzzy ON[/]" if self.fuzzy_search_enabled else "[dim]Fuzzy OFF[/]"
-
-        # Add filter indicators
-        filter_text = ""
-        current_group_filter = getattr(self, "_current_group_filter", None)
-        current_tag_filter = getattr(self, "_current_tag_filter", None)
-
-        if current_group_filter and current_group_filter != "All Groups":
-            filter_text += f" | Group: {current_group_filter}"
-        if current_tag_filter and current_tag_filter != "All Tags":
-            filter_text += f" | Tag: {current_tag_filter}"
-
-        if shown is not None:
-            status.update(f"Showing2 {shown} of {total} aliases | {fuzzy_status}{filter_text} | Press 'p' to apply all")
-        else:
-            status.update(f"Total2: {total} aliases | {fuzzy_status}{filter_text} | Press 'p' to apply all")
-
     def update_info_panel(self, alias: Alias) -> None:
         info = self.query_one("#info-content", Static)
         # Escape any markup characters in the alias data
@@ -1032,3 +1009,17 @@ def action_filter_by_tag(self) -> None:
             self.notify("Showing untagged aliases", severity="information")
         else:
             self.notify(f"Showing aliases with tag: {selected_tag}", severity="information")
+
+    def update_status(self, shown: int = None) -> None:
+        status = self.query_one("#status-bar", Static)
+        total = len(self.storage.list_all())
+
+        current_filter = getattr(self, '_current_group_filter', None)
+        filter_text = ""
+        if current_filter and current_filter != "All Groups":
+            filter_text = f" | Filter: {current_filter}"
+
+        if shown is not None:
+            status.update(f"Showing {shown} of {total} aliases{filter_text} | Press 'g' to filter by group")
+        else:
+            status.update(f"Total: {total} aliases{filter_text} | Press 'g' to filter by group")

From 948849775fab7fe37a922c50d551a79a1ea8cd15 Mon Sep 17 00:00:00 2001
From: Andrew McIntosh <nacho.vonkickbutt@gmail.com>
Date: Sun, 12 Oct 2025 11:26:27 -0400
Subject: [PATCH 3/3] fix: Style fix from rebase

---
 alix/cli.py                    | 67 +++++++++++++-------------
 alix/history_manager.py        | 31 +++++++++---
 alix/template_manager.py       |  7 +--
 alix/tui.py                    |  2 +-
 tests/test_cli_templates.py    |  9 ++--
 tests/test_config.py           |  8 ++--
 tests/test_porter.py           |  8 ++--
 tests/test_shell_wrapper.py    |  6 +--
 tests/test_storage.py          | 48 +++++--------------
 tests/test_template_manager.py | 86 +++++++---------------------------
 tests/test_undo_redo.py        | 76 +++++++++++++-----------------
 tests/test_usage_tracking.py   | 16 ++-----
 12 files changed, 142 insertions(+), 222 deletions(-)

diff --git a/alix/cli.py b/alix/cli.py
index 8b6cbf5..58349c5 100644
--- a/alix/cli.py
+++ b/alix/cli.py
@@ -4,6 +4,7 @@
 from pathlib import Path
 
 import click
+import yaml
 from rich.console import Console
 from rich.markdown import Markdown
 from rich.panel import Panel
@@ -15,7 +16,7 @@
 from alix.porter import AliasPorter
 from alix.render import Render
 from alix.scanner import AliasScanner
-from alix.shell_detector import ShellType
+from alix.shell_detector import ShellDetector, ShellType
 from alix.shell_integrator import ShellIntegrator
 from alix.shell_wrapper import ShellWrapper
 from alix.storage import AliasStorage
@@ -131,7 +132,7 @@ def edit(name, command, description, no_apply):
             created_at=alias.created_at,
             used_count=alias.used_count,
             last_used=alias.last_used,
-            usage_history=alias.usage_history.copy()
+            usage_history=alias.usage_history.copy(),
         )
 
         # Update alias with new values
@@ -147,8 +148,8 @@ def edit(name, command, description, no_apply):
         history_op = {
             "type": "edit",
             "aliases": [original_alias.to_dict()],  # Original state
-            "new_aliases": [alias.to_dict()],       # New state
-            "timestamp": datetime.now().isoformat()
+            "new_aliases": [alias.to_dict()],  # New state
+            "timestamp": datetime.now().isoformat(),
         }
         storage.history.push(history_op)
 
@@ -530,7 +531,7 @@ def list_undo():
         return
 
     console.print("[bold cyan]📚 Undo History (most recent last):[/]")
-    console.print(f"[dim]Use 'alix undo --id <number>' to undo a specific operation[/]")
+    console.print("[dim]Use 'alix undo --id <number>' to undo a specific operation[/]")
 
     for i, op in enumerate(undo_ops, 1):
         op_type = op.get("type", "unknown")
@@ -539,10 +540,9 @@ def list_undo():
 
         # Format timestamp for better readability
         try:
-            from datetime import datetime
-            dt = datetime.fromisoformat(timestamp.replace('Z', '+00:00'))
+            dt = datetime.fromisoformat(timestamp.replace("Z", "+00:00"))
             formatted_time = dt.strftime("%Y-%m-%d %H:%M:%S")
-        except:
+        except Exception:
             formatted_time = timestamp
 
         # Color code by operation type
@@ -593,7 +593,9 @@ def list_undo():
         console.print(f"  [bold]{i}.[/] [{type_color}]{type_icon} {op_type.upper()}[/] {aliases_str}")
         console.print(f"      [dim]at {formatted_time}[/]")
 
-    console.print(f"\n[dim]💡 Tip: Use 'alix undo --id 1' for most recent, 'alix undo --id {len(undo_ops)}' for oldest[/]")
+    console.print(
+        f"\n[dim]💡 Tip: Use 'alix undo --id 1' for most recent, 'alix undo --id {len(undo_ops)}' for oldest[/]"
+    )
 
 
 @main.command()
@@ -605,7 +607,7 @@ def list_redo():
         return
 
     console.print("[bold cyan]🔄 Redo History (most recent last):[/]")
-    console.print(f"[dim]Use 'alix redo --id <number>' to redo a specific operation[/]")
+    console.print("[dim]Use 'alix redo --id <number>' to redo a specific operation[/]")
 
     for i, op in enumerate(redo_ops, 1):
         op_type = op.get("type", "unknown")
@@ -614,10 +616,9 @@ def list_redo():
 
         # Format timestamp for better readability
         try:
-            from datetime import datetime
-            dt = datetime.fromisoformat(timestamp.replace('Z', '+00:00'))
+            dt = datetime.fromisoformat(timestamp.replace("Z", "+00:00"))
             formatted_time = dt.strftime("%Y-%m-%d %H:%M:%S")
-        except:
+        except Exception:
             formatted_time = timestamp
 
         # Color code by operation type
@@ -668,7 +669,9 @@ def list_redo():
         console.print(f"  [bold]{i}.[/] [{type_color}]{type_icon} {op_type.upper()}[/] {aliases_str}")
         console.print(f"      [dim]at {formatted_time}[/]")
 
-    console.print(f"\n[dim]💡 Tip: Use 'alix redo --id 1' for most recent, 'alix redo --id {len(redo_ops)}' for oldest[/]")
+    console.print(
+        f"\n[dim]💡 Tip: Use 'alix redo --id 1' for most recent, 'alix redo --id {len(redo_ops)}' for oldest[/]"
+    )
 
 
 @main.command()
@@ -731,8 +734,6 @@ def setup_tracking(shell, file, standalone, output):
             return
     else:
         # Auto-detect shell
-        from alix.shell_detector import ShellDetector, ShellType
-
         detector = ShellDetector()
         shell_type = detector.detect_current_shell()
         if not shell_type or shell_type == ShellType.UNKNOWN:
@@ -931,14 +932,12 @@ def add_group(group_name, alias_name):
     storage.aliases[alias_name] = alias
     storage.save()
 
-    # Record history for group_add operation
-    from alix.history_manager import HistoryManager
     history_op = {
         "type": "group_add",
         "aliases": [alias.to_dict()],
         "group_name": group_name,
         "old_group": old_group,
-        "timestamp": datetime.now().isoformat()
+        "timestamp": datetime.now().isoformat(),
     }
     storage.history.push(history_op)
 
@@ -971,7 +970,7 @@ def remove_group(group_name, alias_name):
         "aliases": [alias.to_dict()],
         "group_name": group_name,
         "old_group": old_group,
-        "timestamp": datetime.now().isoformat()
+        "timestamp": datetime.now().isoformat(),
     }
     storage.history.push(history_op)
 
@@ -1008,7 +1007,7 @@ def delete_group(group_name, reassign):
             "aliases": [alias.to_dict() for alias in group_aliases],
             "group_name": group_name,
             "reassign_to": new_group,
-            "timestamp": datetime.now().isoformat()
+            "timestamp": datetime.now().isoformat(),
         }
         storage.history.push(history_op)
 
@@ -1027,7 +1026,7 @@ def delete_group(group_name, reassign):
             "aliases": [alias.to_dict() for alias in group_aliases],
             "group_name": group_name,
             "reassign_to": None,
-            "timestamp": datetime.now().isoformat()
+            "timestamp": datetime.now().isoformat(),
         }
         storage.history.push(history_op)
 
@@ -1057,7 +1056,6 @@ def import_group(file, group):
                 continue
 
             alias = Alias.from_dict(alias_data)
-            old_group = alias.group
             alias.group = target_group
             storage.aliases[alias_name] = alias
             imported_count += 1
@@ -1065,13 +1063,20 @@ def import_group(file, group):
         storage.save()
 
         # Record history for group import operation
-        imported_aliases = [storage.get(alias_name) for alias_name in [alias_name for alias_name, _ in data["aliases"].items() if alias_name not in storage.aliases or storage.aliases[alias_name].group != target_group]]
+        imported_aliases = [
+            storage.get(alias_name)
+            for alias_name in [
+                alias_name
+                for alias_name, _ in data["aliases"].items()
+                if alias_name not in storage.aliases or storage.aliases[alias_name].group != target_group
+            ]
+        ]
         if imported_aliases:
             history_op = {
                 "type": "group_import",
                 "aliases": [alias.to_dict() for alias in imported_aliases],
                 "group_name": target_group,
-                "timestamp": datetime.now().isoformat()
+                "timestamp": datetime.now().isoformat(),
             }
             storage.history.push(history_op)
 
@@ -1199,7 +1204,6 @@ def add_tag(alias_name, tags):
 
     # Add new tags (avoid duplicates)
     original_count = len(alias.tags)
-    original_tags = alias.tags.copy()
     added_tags = []
     for tag in tags:
         if tag not in alias.tags:
@@ -1215,7 +1219,7 @@ def add_tag(alias_name, tags):
             "type": "tag_add",
             "aliases": [alias.to_dict()],
             "added_tags": added_tags,
-            "timestamp": datetime.now().isoformat()
+            "timestamp": datetime.now().isoformat(),
         }
         storage.history.push(history_op)
 
@@ -1238,7 +1242,6 @@ def remove_tag(alias_name, tags):
 
     # Remove specified tags
     original_count = len(alias.tags)
-    original_tags = alias.tags.copy()
     removed_tags = []
     for tag in tags:
         if tag in alias.tags:
@@ -1254,7 +1257,7 @@ def remove_tag(alias_name, tags):
             "type": "tag_remove",
             "aliases": [alias.to_dict()],
             "removed_tags": removed_tags,
-            "timestamp": datetime.now().isoformat()
+            "timestamp": datetime.now().isoformat(),
         }
         storage.history.push(history_op)
 
@@ -1313,7 +1316,7 @@ def rename_tag(old_tag, new_tag, dry_run):
             "aliases": updated_aliases,
             "old_tag": old_tag,
             "new_tag": new_tag,
-            "timestamp": datetime.now().isoformat()
+            "timestamp": datetime.now().isoformat(),
         }
         storage.history.push(history_op)
 
@@ -1362,7 +1365,7 @@ def delete_tag(tag_name, dry_run):
             "type": "tag_delete",
             "aliases": updated_aliases,
             "deleted_tag": tag_name,
-            "timestamp": datetime.now().isoformat()
+            "timestamp": datetime.now().isoformat(),
         }
         storage.history.push(history_op)
 
@@ -1443,8 +1446,6 @@ def export_tag(tag_name, file, format):
 
     try:
         if format == "yaml":
-            import yaml
-
             with open(filepath, "w") as f:
                 yaml.dump(export_data, f, default_flow_style=False, sort_keys=False)
         else:  # json
diff --git a/alix/history_manager.py b/alix/history_manager.py
index 18663b1..eddd9a6 100644
--- a/alix/history_manager.py
+++ b/alix/history_manager.py
@@ -1,6 +1,7 @@
 import json
 from datetime import datetime
-from typing import List, Dict, Any, Tuple, Optional
+from pathlib import Path
+from typing import Any, Dict, List, Tuple
 
 from alix.models import Alias
 
@@ -62,13 +63,16 @@ def push(self, op: Dict[str, Any]) -> None:
     def _format_message(self, action: str, op_type: str, count: int, total: int, skipped: int = 0) -> str:
         """Format user-friendly messages with emojis and proper grammar."""
         if skipped > 0:
+            action_message = "restored" if "remove" in op_type else "processed"
             if action in ["Undid", "Redid"]:
-                return f"{action} {op_type} ({count} of {total} aliases {'restored' if 'remove' in op_type else 'processed'}, {skipped} skipped)"
+                return f"{action} {op_type} ({count} of {total} aliases {action_message}, {skipped} skipped)"
             else:
-                return f"{action} {op_type} ({count} of {total} aliases {'restored' if 'remove' in op_type else 'processed'}, {skipped} skipped)"
+                return f"{action} {op_type} ({count} of {total} aliases {action_message}, {skipped} skipped)"
 
         if count != total:
-            return f"{action} {op_type} ({count} of {total} aliases {'restored' if 'remove' in op_type else 'processed'})"
+            return (
+                f"{action} {op_type} ({count} of {total} aliases {'restored' if 'remove' in op_type else 'processed'})"
+            )
 
         # Handle pluralization
         alias_word = "aliases" if count != 1 else "alias"
@@ -78,7 +82,16 @@ def _format_message(self, action: str, op_type: str, count: int, total: int, ski
             return f"{action} {op_type} ({count} {alias_word} {'added' if action == 'Redid' else 'removed'})"
         elif op_type == "edit":
             return f"{action} {op_type} ({count} {alias_word} {'updated' if action == 'Redid' else 'restored'})"
-        elif op_type in ["group_add", "group_remove", "tag_add", "tag_remove", "tag_rename", "tag_delete", "group_delete", "group_import"]:
+        elif op_type in [
+            "group_add",
+            "group_remove",
+            "tag_add",
+            "tag_remove",
+            "tag_rename",
+            "tag_delete",
+            "group_delete",
+            "group_import",
+        ]:
             return f"{action} {op_type} ({count} {alias_word} {'processed' if action == 'Redid' else 'processed'})"
         elif op_type == "rename":
             return f"{action} {op_type} ({count} {alias_word} {'renamed' if action == 'Redid' else 'renamed back'})"
@@ -532,7 +545,9 @@ def _load_alias(self, data: Dict[str, Any]) -> Alias:
             raise
 
     def perform_undo(self, storage) -> str:
-        """Undo last op. storage must implement add(alias, record_history=False) and remove(name, record_history=False)."""
+        """Undo last op. storage must implement add(alias, record_history=False)
+        and remove(name, record_history=False).
+        """
         if not self.undo:
             return "⚠️  Nothing to undo – history is empty."
 
@@ -548,7 +563,9 @@ def perform_undo(self, storage) -> str:
         return f"✅ {message}"
 
     def perform_redo(self, storage) -> str:
-        """Redo last undone op. storage must implement add(alias, record_history=False) and remove(name, record_history=False)."""
+        """Redo last undone op. storage must implement add(alias, record_history=False)
+        and remove(name, record_history=False).
+        """
         if not self.redo:
             return "⚠️  Nothing to redo – already at the latest state."
 
diff --git a/alix/template_manager.py b/alix/template_manager.py
index 8cc9659..61cb301 100644
--- a/alix/template_manager.py
+++ b/alix/template_manager.py
@@ -1,7 +1,8 @@
-import yaml
-from pathlib import Path
-from typing import List, Dict, Optional
 from dataclasses import dataclass
+from pathlib import Path
+from typing import Dict, List, Optional
+
+import yaml
 
 from alix.models import Alias
 from alix.storage import AliasStorage
diff --git a/alix/tui.py b/alix/tui.py
index 32770f0..487a28a 100644
--- a/alix/tui.py
+++ b/alix/tui.py
@@ -1014,7 +1014,7 @@ def update_status(self, shown: int = None) -> None:
         status = self.query_one("#status-bar", Static)
         total = len(self.storage.list_all())
 
-        current_filter = getattr(self, '_current_group_filter', None)
+        current_filter = getattr(self, "_current_group_filter", None)
         filter_text = ""
         if current_filter and current_filter != "All Groups":
             filter_text = f" | Filter: {current_filter}"
diff --git a/tests/test_cli_templates.py b/tests/test_cli_templates.py
index f083cf2..c5a4288 100644
--- a/tests/test_cli_templates.py
+++ b/tests/test_cli_templates.py
@@ -1,6 +1,7 @@
+from unittest.mock import MagicMock, patch
+
 import pytest
 from click.testing import CliRunner
-from unittest.mock import patch, MagicMock
 
 from alix.cli import main
 from alix.template_manager import TemplateManager
@@ -25,7 +26,7 @@ def mock_template_manager(self):
         mock_template.description = "Git version control aliases"
         mock_template.aliases = [
             MagicMock(name="gs", command="git status", description="Git status", tags=["git"]),
-            MagicMock(name="ga", command="git add", description="Git add", tags=["git"])
+            MagicMock(name="ga", command="git add", description="Git add", tags=["git"]),
         ]
 
         mock_manager.list_templates.return_value = [mock_template]
@@ -82,7 +83,7 @@ def test_templates_add_command_dry_run(self, mock_template_manager_class, runner
         mock_template.description = "Git version control aliases"
         mock_template.aliases = [
             Alias(name="gs", command="git status", description="Git status", tags=["git"]),
-            Alias(name="ga", command="git add", description="Git add", tags=["git"])
+            Alias(name="ga", command="git add", description="Git add", tags=["git"]),
         ]
         mock_template_manager.get_template.return_value = mock_template
         mock_template_manager_class.return_value = mock_template_manager
@@ -155,4 +156,4 @@ def test_templates_help(self, runner):
         assert "Manage alias templates" in result.output
         assert "list" in result.output
         assert "add" in result.output
-        assert "add-category" in result.output
\ No newline at end of file
+        assert "add-category" in result.output
diff --git a/tests/test_config.py b/tests/test_config.py
index ee20c2a..857cf8f 100644
--- a/tests/test_config.py
+++ b/tests/test_config.py
@@ -20,9 +20,9 @@ def temp_config_dir(self, tmp_path):
     def test_init(self):
         """Test Config initialization"""
         config = Config()
-        assert hasattr(config, 'config_dir')
-        assert hasattr(config, 'config_path')
-        assert hasattr(config, 'config')
+        assert hasattr(config, "config_dir")
+        assert hasattr(config, "config_path")
+        assert hasattr(config, "config")
         assert isinstance(config.config, dict)
 
     def test_load_no_config_file(self, temp_config_dir):
@@ -181,4 +181,4 @@ def test_get_theme_missing_theme_config(self):
 
         theme = config.get_theme()
         # Should fall back to default theme
-        assert theme == Config.THEMES["default"]
\ No newline at end of file
+        assert theme == Config.THEMES["default"]
diff --git a/tests/test_porter.py b/tests/test_porter.py
index 2e55e33..10fe0ef 100644
--- a/tests/test_porter.py
+++ b/tests/test_porter.py
@@ -1,9 +1,9 @@
 from pathlib import Path
 from unittest.mock import Mock, mock_open, patch
 
+from alix.models import Alias
 from alix.porter import AliasPorter
 from alix.storage import AliasStorage
-from alix.models import Alias
 
 
 def test_export_to_dict__from_list(alias_list, porter_data):
@@ -228,7 +228,7 @@ def test_import_from_file_with_tag_filter(self, mock_json):
             "aliases": [
                 {"name": "alias1", "command": "echo 1", "tags": ["tag1"]},
                 {"name": "alias2", "command": "echo 2", "tags": ["tag2"]},
-                {"name": "alias3", "command": "echo 3", "tags": ["tag1", "tag2"]}
+                {"name": "alias3", "command": "echo 3", "tags": ["tag1", "tag2"]},
             ]
         }
         mock_json.load.return_value = import_data
@@ -236,9 +236,7 @@ def test_import_from_file_with_tag_filter(self, mock_json):
         porter = AliasPorter()
         porter.storage = mock_storage
 
-        with patch("alix.porter.open", mocked_open), patch(
-            "pathlib.Path.exists", autospec=True
-        ) as mock_exists:
+        with patch("alix.porter.open", mocked_open), patch("pathlib.Path.exists", autospec=True) as mock_exists:
             mock_exists.return_value = True
 
             result = porter.import_from_file(Path("/tmp/test.json"), tag_filter="tag1")
diff --git a/tests/test_shell_wrapper.py b/tests/test_shell_wrapper.py
index 24b8301..1c0fa06 100644
--- a/tests/test_shell_wrapper.py
+++ b/tests/test_shell_wrapper.py
@@ -2,7 +2,7 @@
 
 import tempfile
 from pathlib import Path
-from unittest.mock import Mock, mock_open, patch
+from unittest.mock import Mock, patch
 
 from alix.shell_wrapper import ShellWrapper
 
@@ -122,7 +122,7 @@ def test_generate_shell_integration_script_fish(self):
 
         assert "Alix CLI Usage Tracking Integration for Fish" in result
         # Since there are no aliases, no functions are generated
-        assert "echo \"Alix usage tracking enabled for 0 aliases\"" in result
+        assert 'echo "Alix usage tracking enabled for 0 aliases"' in result
 
     @patch("alix.shell_wrapper.os.chmod")
     def test_create_standalone_tracking_script_directory_creation(self, mock_chmod):
@@ -163,4 +163,4 @@ def test_create_standalone_tracking_script_exception_handling(self):
             with patch("alix.shell_wrapper.open", side_effect=Exception("File write error")):
                 result = wrapper.create_standalone_tracking_script(output_path, "bash")
 
-            assert result is False
\ No newline at end of file
+            assert result is False
diff --git a/tests/test_storage.py b/tests/test_storage.py
index 29327db..2d4cdc1 100644
--- a/tests/test_storage.py
+++ b/tests/test_storage.py
@@ -3,8 +3,8 @@
 
 from freezegun import freeze_time
 
-from alix.storage import AliasStorage
 from alix.models import Alias
+from alix.storage import AliasStorage
 
 
 @patch.object(AliasStorage, "load")
@@ -232,7 +232,9 @@ def test_restore_latest_backup__no_backups(mock_shutil):
 class TestStorageGroupAndTagMethods:
     """Test storage methods for groups and tags"""
 
-    def test_clear_test_alias(self,):
+    def test_clear_test_alias(
+        self,
+    ):
         """Test clear_test_alias method"""
         storage = AliasStorage()
         test_alias = Alias(name="alix-test-echo", command="echo test")
@@ -256,11 +258,7 @@ def test_get_by_group(self):
         alias2 = Alias(name="alias2", command="echo 2", group="group1")
         alias3 = Alias(name="alias3", command="echo 3", group="group2")
 
-        storage.aliases = {
-            "alias1": alias1,
-            "alias2": alias2,
-            "alias3": alias3
-        }
+        storage.aliases = {"alias1": alias1, "alias2": alias2, "alias3": alias3}
 
         group1_aliases = storage.get_by_group("group1")
         group2_aliases = storage.get_by_group("group2")
@@ -282,12 +280,7 @@ def test_get_groups(self):
         alias3 = Alias(name="alias3", command="echo 3", group="group1")
         alias4 = Alias(name="alias4", command="echo 4")
 
-        storage.aliases = {
-            "alias1": alias1,
-            "alias2": alias2,
-            "alias3": alias3,
-            "alias4": alias4
-        }
+        storage.aliases = {"alias1": alias1, "alias2": alias2, "alias3": alias3, "alias4": alias4}
 
         groups = storage.get_groups()
 
@@ -319,11 +312,7 @@ def test_remove_group_with_aliases(self):
             alias2 = Alias(name="alias2", command="echo 2", group="group1")
             alias3 = Alias(name="alias3", command="echo 3", group="group2")
 
-            storage.aliases = {
-                "alias1": alias1,
-                "alias2": alias2,
-                "alias3": alias3
-            }
+            storage.aliases = {"alias1": alias1, "alias2": alias2, "alias3": alias3}
 
             storage.save()
 
@@ -354,11 +343,7 @@ def test_get_by_tag(self):
         alias2 = Alias(name="alias2", command="echo 2", tags=["tag2"])
         alias3 = Alias(name="alias3", command="echo 3", tags=["tag3"])
 
-        storage.aliases = {
-            "alias1": alias1,
-            "alias2": alias2,
-            "alias3": alias3
-        }
+        storage.aliases = {"alias1": alias1, "alias2": alias2, "alias3": alias3}
 
         tag1_aliases = storage.get_by_tag("tag1")
         tag2_aliases = storage.get_by_tag("tag2")
@@ -380,11 +365,7 @@ def test_get_tags(self):
         alias2 = Alias(name="alias2", command="echo 2", tags=["tag2", "tag3"])
         alias3 = Alias(name="alias3", command="echo 3", tags=[])
 
-        storage.aliases = {
-            "alias1": alias1,
-            "alias2": alias2,
-            "alias3": alias3
-        }
+        storage.aliases = {"alias1": alias1, "alias2": alias2, "alias3": alias3}
 
         tags = storage.get_tags()
 
@@ -398,11 +379,7 @@ def test_get_tag_counts(self):
         alias2 = Alias(name="alias2", command="echo 2", tags=["tag2"])
         alias3 = Alias(name="alias3", command="echo 3", tags=["tag1"])
 
-        storage.aliases = {
-            "alias1": alias1,
-            "alias2": alias2,
-            "alias3": alias3
-        }
+        storage.aliases = {"alias1": alias1, "alias2": alias2, "alias3": alias3}
 
         tag_counts = storage.get_tag_counts()
 
@@ -421,10 +398,7 @@ def test_remove_group_with_remove_failure(self):
             alias1 = Alias(name="alias1", command="echo 1", group="group1")
             alias2 = Alias(name="alias2", command="echo 2", group="group1")
 
-            storage.aliases = {
-                "alias1": alias1,
-                "alias2": alias2
-            }
+            storage.aliases = {"alias1": alias1, "alias2": alias2}
 
             def mock_remove(name, record_history=False):
                 return False
diff --git a/tests/test_template_manager.py b/tests/test_template_manager.py
index 7a440a2..e40debf 100644
--- a/tests/test_template_manager.py
+++ b/tests/test_template_manager.py
@@ -1,6 +1,7 @@
+from unittest.mock import MagicMock, patch
+
 import pytest
 import yaml
-from unittest.mock import patch, MagicMock
 
 from alix.template_manager import TemplateManager
 
@@ -19,19 +20,9 @@ def temp_templates_dir(self, tmp_path):
             "category": "test",
             "description": "Test template",
             "aliases": [
-                {
-                    "name": "test1",
-                    "command": "echo test1",
-                    "description": "Test alias 1",
-                    "tags": ["test"]
-                },
-                {
-                    "name": "test2",
-                    "command": "echo test2",
-                    "description": "Test alias 2",
-                    "tags": ["test"]
-                }
-            ]
+                {"name": "test1", "command": "echo test1", "description": "Test alias 1", "tags": ["test"]},
+                {"name": "test2", "command": "echo test2", "description": "Test alias 2", "tags": ["test"]},
+            ],
         }
 
         with open(templates_dir / "valid.yaml", "w") as f:
@@ -40,12 +31,7 @@ def temp_templates_dir(self, tmp_path):
         with open(templates_dir / "malformed.yaml", "w") as f:
             f.write("invalid: yaml: content: [\n")
 
-        empty_template = {
-            "version": "1.0",
-            "category": "empty",
-            "description": "Empty template",
-            "aliases": []
-        }
+        empty_template = {"version": "1.0", "category": "empty", "description": "Empty template", "aliases": []}
 
         with open(templates_dir / "empty.yaml", "w") as f:
             yaml.dump(empty_template, f)
@@ -57,9 +43,9 @@ def test_init_with_templates_dir(self, temp_templates_dir):
         manager = TemplateManager()
         manager.templates_dir = temp_templates_dir
 
-        assert hasattr(manager, '_templates')
-        assert hasattr(manager, 'templates_dir')
-        assert hasattr(manager, 'storage')
+        assert hasattr(manager, "_templates")
+        assert hasattr(manager, "templates_dir")
+        assert hasattr(manager, "storage")
 
     def test_load_templates_success(self, temp_templates_dir):
         """Test successful template loading"""
@@ -232,35 +218,19 @@ def test_validate_template_data_missing_required_fields(self):
         manager = TemplateManager()
 
         # Missing version
-        data = {
-            "category": "test",
-            "description": "test",
-            "aliases": []
-        }
+        data = {"category": "test", "description": "test", "aliases": []}
         assert not manager._validate_template_data(data, "test.yaml")
 
         # Missing category
-        data = {
-            "version": "1.0",
-            "description": "test",
-            "aliases": []
-        }
+        data = {"version": "1.0", "description": "test", "aliases": []}
         assert not manager._validate_template_data(data, "test.yaml")
 
         # Missing description
-        data = {
-            "version": "1.0",
-            "category": "test",
-            "aliases": []
-        }
+        data = {"version": "1.0", "category": "test", "aliases": []}
         assert not manager._validate_template_data(data, "test.yaml")
 
         # Missing aliases
-        data = {
-            "version": "1.0",
-            "category": "test",
-            "description": "test"
-        }
+        data = {"version": "1.0", "category": "test", "description": "test"}
         assert not manager._validate_template_data(data, "test.yaml")
 
     def test_validate_template_data_invalid_aliases_list(self):
@@ -268,12 +238,7 @@ def test_validate_template_data_invalid_aliases_list(self):
         manager = TemplateManager()
 
         # Aliases is not a list
-        data = {
-            "version": "1.0",
-            "category": "test",
-            "description": "test",
-            "aliases": "invalid"
-        }
+        data = {"version": "1.0", "category": "test", "description": "test", "aliases": "invalid"}
         assert not manager._validate_template_data(data, "test.yaml")
 
     def test_validate_template_data_invalid_alias_data(self):
@@ -281,12 +246,7 @@ def test_validate_template_data_invalid_alias_data(self):
         manager = TemplateManager()
 
         # Alias is not a dict
-        data = {
-            "version": "1.0",
-            "category": "test",
-            "description": "test",
-            "aliases": ["invalid"]
-        }
+        data = {"version": "1.0", "category": "test", "description": "test", "aliases": ["invalid"]}
         assert not manager._validate_template_data(data, "test.yaml")
 
     def test_validate_template_data_missing_alias_fields(self):
@@ -294,21 +254,11 @@ def test_validate_template_data_missing_alias_fields(self):
         manager = TemplateManager()
 
         # Missing name
-        data = {
-            "version": "1.0",
-            "category": "test",
-            "description": "test",
-            "aliases": [{"command": "echo test"}]
-        }
+        data = {"version": "1.0", "category": "test", "description": "test", "aliases": [{"command": "echo test"}]}
         assert not manager._validate_template_data(data, "test.yaml")
 
         # Missing command
-        data = {
-            "version": "1.0",
-            "category": "test",
-            "description": "test",
-            "aliases": [{"name": "test"}]
-        }
+        data = {"version": "1.0", "category": "test", "description": "test", "aliases": [{"name": "test"}]}
         assert not manager._validate_template_data(data, "test.yaml")
 
     def test_load_templates_exception_handling(self, tmp_path):
@@ -428,4 +378,4 @@ def test_import_by_category_with_filter(self, mock_storage_class, temp_templates
 
         assert success is True
         assert "Imported 1 aliases" in message
-        assert mock_storage.add.call_count == 1
\ No newline at end of file
+        assert mock_storage.add.call_count == 1
diff --git a/tests/test_undo_redo.py b/tests/test_undo_redo.py
index c029d91..8e8cc36 100644
--- a/tests/test_undo_redo.py
+++ b/tests/test_undo_redo.py
@@ -1,3 +1,4 @@
+import stat
 from datetime import datetime
 
 import pytest
@@ -147,6 +148,7 @@ def test_partial_failures(temp_storage):
     msg = temp_storage.history.perform_undo(temp_storage)
     assert "skipped" in msg.lower()
 
+
 def test_multiple_undos_redos(temp_storage):
     # Add multiple aliases
     for i in range(3):
@@ -170,6 +172,7 @@ def test_multiple_undos_redos(temp_storage):
     msg = temp_storage.history.perform_redo(temp_storage)
     assert "⚠️  Nothing to redo – already at the latest state." in msg
 
+
 def test_remove_nonexistent(temp_storage):
     # Remove alias that does not exist
     result = temp_storage.remove("ghost_alias", record_history=True)
@@ -369,7 +372,7 @@ def test_rename_operation_undo_redo(temp_storage):
         "aliases": [{"name": "old_name", "command": "echo hello"}],
         "old_name": "old_name",
         "new_name": "new_name",
-        "timestamp": datetime.now().isoformat()
+        "timestamp": datetime.now().isoformat(),
     }
     temp_storage.history.push(rename_op)
 
@@ -406,12 +409,9 @@ def test_group_operations_undo_redo(temp_storage):
     # Add to group (simulate group_add operation)
     group_add_op = {
         "type": "group_add",
-        "aliases": [
-            {"name": "test1", "command": "echo one"},
-            {"name": "test2", "command": "echo two"}
-        ],
+        "aliases": [{"name": "test1", "command": "echo one"}, {"name": "test2", "command": "echo two"}],
         "group_name": "test_group",
-        "timestamp": datetime.now().isoformat()
+        "timestamp": datetime.now().isoformat(),
     }
     temp_storage.history.push(group_add_op)
 
@@ -450,7 +450,7 @@ def test_tag_operations_undo_redo(temp_storage):
         "type": "tag_add",
         "aliases": [{"name": "test", "command": "echo hello", "tags": ["old"]}],
         "added_tags": ["new_tag"],
-        "timestamp": datetime.now().isoformat()
+        "timestamp": datetime.now().isoformat(),
     }
     temp_storage.history.push(tag_add_op)
 
@@ -483,9 +483,9 @@ def test_import_operation_undo_redo(temp_storage):
         "type": "import",
         "aliases": [
             {"name": "imported1", "command": "echo imported1"},
-            {"name": "imported2", "command": "echo imported2"}
+            {"name": "imported2", "command": "echo imported2"},
         ],
-        "timestamp": datetime.now().isoformat()
+        "timestamp": datetime.now().isoformat(),
     }
     temp_storage.history.push(import_op)
 
@@ -573,7 +573,7 @@ def test_corrupted_history_during_operations(temp_storage, tmp_path):
 
     # Corrupt the history file
     history_file = tmp_path / "aliases_history.json"
-    with open(history_file, 'w') as f:
+    with open(history_file, "w") as f:
         f.write("{ invalid json content }")
 
     # Try to undo - should handle gracefully
@@ -593,7 +593,7 @@ def test_invalid_operation_data_handling(temp_storage):
     invalid_op = {
         "type": "add",
         # Missing "aliases" field
-        "timestamp": datetime.now().isoformat()
+        "timestamp": datetime.now().isoformat(),
     }
 
     # This should raise an error when pushing
@@ -604,11 +604,7 @@ def test_invalid_operation_data_handling(temp_storage):
         pass  # Expected
 
     # Push operation with empty aliases
-    empty_op = {
-        "type": "add",
-        "aliases": [],
-        "timestamp": datetime.now().isoformat()
-    }
+    empty_op = {"type": "add", "aliases": [], "timestamp": datetime.now().isoformat()}
     temp_storage.history.push(empty_op)
 
     # Undo should handle empty aliases gracefully
@@ -653,9 +649,6 @@ def failing_add(alias, record_history=False):
 
 def test_history_file_permission_errors(tmp_path):
     """Test handling of file permission errors."""
-    # Create a read-only directory for history
-    import os
-    import stat
 
     readonly_dir = tmp_path / "readonly"
     readonly_dir.mkdir()
@@ -672,12 +665,14 @@ def test_history_file_permission_errors(tmp_path):
         history = HistoryManager(path=readonly_file)
 
         # Try operations that require writing
-        alias = Alias(name="test", command="echo hello")
-        history.push({
-            "type": "add",
-            "aliases": [{"name": "test", "command": "echo hello"}],
-            "timestamp": datetime.now().isoformat()
-        })
+        Alias(name="test", command="echo hello")
+        history.push(
+            {
+                "type": "add",
+                "aliases": [{"name": "test", "command": "echo hello"}],
+                "timestamp": datetime.now().isoformat(),
+            }
+        )
 
         # Should handle gracefully (fail silently as per current implementation)
         undo_msg = history.perform_undo(None)  # Pass None storage to avoid other errors
@@ -693,16 +688,9 @@ def test_very_large_history_operations(temp_storage):
     # Create operation with many aliases
     many_aliases = []
     for i in range(100):  # Large number of aliases
-        many_aliases.append({
-            "name": f"alias{i}",
-            "command": f"echo {i}"
-        })
+        many_aliases.append({"name": f"alias{i}", "command": f"echo {i}"})
 
-    large_op = {
-        "type": "add",
-        "aliases": many_aliases,
-        "timestamp": datetime.now().isoformat()
-    }
+    large_op = {"type": "add", "aliases": many_aliases, "timestamp": datetime.now().isoformat()}
     temp_storage.history.push(large_op)
 
     # Add all aliases to storage
@@ -730,7 +718,7 @@ def test_malformed_alias_data_in_history(temp_storage):
             {"command": "echo no_name"},  # Missing name
             {"name": "no_command"},  # Missing command
         ],
-        "timestamp": datetime.now().isoformat()
+        "timestamp": datetime.now().isoformat(),
     }
     temp_storage.history.push(malformed_op)
 
@@ -753,8 +741,6 @@ def test_malformed_alias_data_in_history(temp_storage):
 
 def test_concurrent_history_modifications(temp_storage):
     """Test handling of concurrent modifications to history."""
-    # Get initial history state
-    initial_undo_count = len(temp_storage.history.list_undo())
 
     # Simulate concurrent modification by directly modifying the lists
     original_undo = temp_storage.history.undo[:]
@@ -765,11 +751,13 @@ def test_concurrent_history_modifications(temp_storage):
     temp_storage.add(alias, record_history=True)
 
     # Simulate concurrent modification (another process modified history)
-    temp_storage.history.undo.append({
-        "type": "add",
-        "aliases": [{"name": "concurrent", "command": "echo concurrent"}],
-        "timestamp": datetime.now().isoformat()
-    })
+    temp_storage.history.undo.append(
+        {
+            "type": "add",
+            "aliases": [{"name": "concurrent", "command": "echo concurrent"}],
+            "timestamp": datetime.now().isoformat(),
+        }
+    )
 
     # Try to undo - should handle the concurrent modification gracefully
     msg = temp_storage.history.perform_undo(temp_storage)
@@ -832,7 +820,7 @@ def test_group_delete_undo_redo_without_reassignment(temp_storage):
         "aliases": [alias.to_dict() for alias in group_aliases],
         "group_name": "testgroup",
         "reassign_to": None,  # No reassignment
-        "timestamp": "2025-01-01T00:00:00.000000"
+        "timestamp": "2025-01-01T00:00:00.000000",
     }
     temp_storage.history.push(history_op)
 
@@ -878,7 +866,7 @@ def test_group_delete_undo_redo_with_reassignment(temp_storage):
         "aliases": [alias.to_dict() for alias in group_aliases],
         "group_name": "oldgroup",
         "reassign_to": "newgroup",  # Reassignment target
-        "timestamp": "2025-01-01T00:00:00.000000"
+        "timestamp": "2025-01-01T00:00:00.000000",
     }
     temp_storage.history.push(history_op)
 
diff --git a/tests/test_usage_tracking.py b/tests/test_usage_tracking.py
index cecc7f9..4db57d0 100644
--- a/tests/test_usage_tracking.py
+++ b/tests/test_usage_tracking.py
@@ -498,7 +498,7 @@ def test_alias_from_dict_with_string_created_at(self):
             "name": "test_alias",
             "command": "echo hello",
             "created_at": past_time,  # String format to trigger conversion
-            "used_count": 0
+            "used_count": 0,
         }
 
         # Create alias from dict - this should trigger the created_at conversion
@@ -518,12 +518,7 @@ def test_alias_from_dict_with_usage_history(self):
             "name": "test_alias",
             "command": "echo hello",
             "used_count": 1,
-            "usage_history": [
-                {
-                    "timestamp": usage_time,
-                    "context": "test context"
-                }
-            ]
+            "usage_history": [{"timestamp": usage_time, "context": "test context"}],
         }
 
         # Create alias from dict - this should trigger usage_history conversion
@@ -547,12 +542,7 @@ def test_alias_from_dict_with_both_conversions(self):
             "command": "echo hello",
             "created_at": created_time,  # String format
             "used_count": 1,
-            "usage_history": [
-                {
-                    "timestamp": usage_time,
-                    "context": "test context"
-                }
-            ]
+            "usage_history": [{"timestamp": usage_time, "context": "test context"}],
         }
 
         # Create alias from dict - this should trigger both conversions