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..0183d74 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,14 @@ 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
+
 test: dev-install  ## Run tests
 	$(VENV)/bin/pytest
 
diff --git a/alix/cli.py b/alix/cli.py
index 2eae93a..58349c5 100644
--- a/alix/cli.py
+++ b/alix/cli.py
@@ -1,26 +1,25 @@
-import click
+import json
 import subprocess
-from pathlib import Path
 from datetime import datetime
+from pathlib import Path
+
+import click
+import yaml
 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 ShellDetector, 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 +66,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 +104,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 +116,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:
@@ -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)
 
@@ -164,7 +165,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 +256,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 +337,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 +423,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 +431,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 +446,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]
@@ -531,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")
@@ -540,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
@@ -594,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()
@@ -606,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")
@@ -615,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
@@ -669,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()
@@ -706,7 +708,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:
@@ -732,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:
@@ -750,7 +750,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 +768,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 +837,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 +846,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 +861,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 +877,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 +912,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:
@@ -932,24 +932,22 @@ def add(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)
 
     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:
@@ -972,18 +970,18 @@ def remove(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)
 
     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]
@@ -1009,7 +1007,7 @@ def delete(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)
 
@@ -1028,14 +1026,14 @@ def delete(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)
 
         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 +1043,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")
@@ -1058,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
@@ -1066,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)
 
@@ -1084,10 +1088,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 +1127,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 +1161,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 +1192,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:
@@ -1200,7 +1204,6 @@ def add(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:
@@ -1216,7 +1219,7 @@ def add(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)
 
@@ -1227,10 +1230,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:
@@ -1239,7 +1242,6 @@ def remove(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:
@@ -1255,7 +1257,7 @@ def remove(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)
 
@@ -1264,16 +1266,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]
@@ -1314,17 +1316,17 @@ def rename(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)
 
     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]
@@ -1363,7 +1365,7 @@ def delete(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)
 
@@ -1380,7 +1382,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 +1415,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]
@@ -1444,8 +1446,6 @@ def export(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
@@ -1481,20 +1481,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 +1507,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 +1535,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 +1572,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 +1629,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 +1664,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 +1674,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..eddd9a6 100644
--- a/alix/history_manager.py
+++ b/alix/history_manager.py
@@ -1,7 +1,7 @@
 import json
-from pathlib import Path
 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
 
@@ -63,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"
@@ -79,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'})"
@@ -533,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."
 
@@ -549,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/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..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, Any, 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
@@ -10,6 +11,7 @@
 @dataclass
 class Template:
     """Represents a template with metadata and aliases"""
+
     name: str
     category: str
     description: str
@@ -72,7 +74,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 +83,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 +163,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..487a28a 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
@@ -761,34 +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"Showing {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"
-            )
-
     def update_info_panel(self, alias: Alias) -> None:
         info = self.query_one("#info-content", Static)
         # Escape any markup characters in the alias data
@@ -800,7 +746,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 +799,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 +823,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 +882,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 +899,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 +907,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 +930,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 +960,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 +976,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")
@@ -1072,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}"
@@ -1080,4 +1022,4 @@ def update_status(self, shown: int = None) -> None:
         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
+            status.update(f"Total: {total} aliases{filter_text} | Press 'g' to filter by group")
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_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_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..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):
@@ -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"))
@@ -245,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
@@ -253,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_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_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 cf678c2..2d4cdc1 100644
--- a/tests/test_storage.py
+++ b/tests/test_storage.py
@@ -1,10 +1,10 @@
 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
 
-from alix.storage import AliasStorage
 from alix.models import Alias
+from alix.storage import AliasStorage
 
 
 @patch.object(AliasStorage, "load")
@@ -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")
@@ -241,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")
@@ -265,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")
@@ -291,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()
 
@@ -328,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()
 
@@ -363,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")
@@ -389,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()
 
@@ -407,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()
 
@@ -430,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_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..8e8cc36 100644
--- a/tests/test_undo_redo.py
+++ b/tests/test_undo_redo.py
@@ -1,9 +1,11 @@
-import pytest
+import stat
 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 +21,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 +42,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 +65,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 +106,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 +116,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,19 +135,20 @@ 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()
 
+
 def test_multiple_undos_redos(temp_storage):
     # Add multiple aliases
     for i in range(3):
@@ -169,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)
@@ -368,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)
 
@@ -405,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)
 
@@ -449,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)
 
@@ -482,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)
 
@@ -572,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
@@ -592,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
@@ -603,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
@@ -652,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()
@@ -671,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
@@ -692,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
@@ -729,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)
 
@@ -752,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[:]
@@ -764,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)
@@ -831,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)
 
@@ -877,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 57d7f8b..4db57d0 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
@@ -510,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
@@ -530,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
@@ -559,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