tunacode-cli 0.0.76.4__py3-none-any.whl → 0.0.76.6__py3-none-any.whl

tunacode/cli/commands/registry.py

@@ -5,7 +5,6 @@ CLAUDE_ANCHOR[command-registry]: Central command registration and execution
 
 import logging
 from dataclasses import dataclass
-from difflib import get_close_matches
 from pathlib import Path
 from typing import Any, Dict, List, Optional, Type
 
@@ -315,16 +314,12 @@ class CommandRegistry:
         self.discover_commands()
         partial = partial_command.lower()
 
-        # 1) Prefer prefix matches (preserves current behavior)
+        # CLAUDE_ANCHOR[key=86cc1a41] Prefix-only command matching after removing fuzzy fallback
         prefix_matches = [cmd for cmd in self._commands.keys() if cmd.startswith(partial)]
         if prefix_matches:
             return prefix_matches
 
-        # 2) Fuzzy fallback for typos and near-misses
-        # CLAUDE_ANCHOR[fuzzy-command-matching]: Fuzzy fallback using difflib
-        # Keep minimal change: reuse built-ins, avoid new deps.
-        fuzzy = get_close_matches(partial, list(self._commands.keys()), n=3, cutoff=0.75)
-        return fuzzy
+        return []
 
     def is_command(self, text: str) -> bool:
         """Check if text starts with a registered command (supports partial matching)."""

tunacode/cli/main.py

@@ -19,7 +19,7 @@ from tunacode.ui import console as ui
 from tunacode.utils.system import check_for_updates
 
 app_settings = ApplicationSettings()
-app = typer.Typer(help="TunaCode - OS AI-powered CLI Coding Tool")
+app = typer.Typer(help="TunaCode - OS AI-powered development assistant")
 state_manager = StateManager()
 
 

tunacode/constants.py

@@ -9,7 +9,7 @@ from enum import Enum
 
 # Application info
 APP_NAME = "TunaCode"
-APP_VERSION = "0.0.76.4"
+APP_VERSION = "0.0.76.6"
 
 
 # File patterns

tunacode/ui/completers.py

@@ -1,17 +1,20 @@
 """Completers for file references and commands."""
 
 import os
-from typing import TYPE_CHECKING, Iterable, List, Optional
+from typing import TYPE_CHECKING, Iterable, List, Optional, Sequence, Set, Tuple
 
 from prompt_toolkit.completion import (
     CompleteEvent,
     Completer,
     Completion,
+    FuzzyCompleter,
+    FuzzyWordCompleter,
+    PathCompleter,
     merge_completers,
 )
 from prompt_toolkit.document import Document
 
-from ..utils.fuzzy_utils import find_fuzzy_matches
+from .path_heuristics import prioritize_roots, should_skip_directory
 
 if TYPE_CHECKING:
     from ..cli.commands import CommandRegistry
@@ -21,6 +24,17 @@ if TYPE_CHECKING:
 class CommandCompleter(Completer):
     """Completer for slash commands."""
 
+    _DEFAULT_COMMANDS: Sequence[str] = (
+        "/help",
+        "/clear",
+        "/dump",
+        "/yolo",
+        "/branch",
+        "/compact",
+        "/model",
+    )
+    _FUZZY_WORD_MODE = True
+
     def __init__(self, command_registry: Optional["CommandRegistry"] = None):
         self.command_registry = command_registry
 
@@ -52,33 +66,34 @@ class CommandCompleter(Completer):
         if self.command_registry:
             command_names = self.command_registry.get_command_names()
         else:
-            # Fallback list of commands
-            command_names = ["/help", "/clear", "/dump", "/yolo", "/branch", "/compact", "/model"]
+            command_names = list(self._DEFAULT_COMMANDS)
 
-        # Get the partial command (without /)
-        partial = word_before_cursor[1:].lower()
-
-        # Yield completions for matching commands
-        for cmd in command_names:
-            if cmd.startswith("/") and cmd[1:].lower().startswith(partial):
-                yield Completion(
-                    text=cmd,
-                    start_position=-len(word_before_cursor),
-                    display=cmd,
-                    display_meta="command",
-                )
+        fuzzy_completer = FuzzyWordCompleter(command_names, WORD=self._FUZZY_WORD_MODE)
+        for completion in fuzzy_completer.get_completions(document, _complete_event):
+            yield Completion(
+                text=completion.text,
+                start_position=completion.start_position,
+                display=completion.display,
+                display_meta="command",
+            )
 
 
 class FileReferenceCompleter(Completer):
     """Completer for @file references that provides file path suggestions."""
 
+    _FUZZY_WORD_MODE = True
+    _FUZZY_RESULT_LIMIT = 10
+    _GLOBAL_ROOT_CACHE: Optional[List[str]] = None
+    _GLOBAL_ROOT_LIMIT = 128
+    _GLOBAL_MAX_DEPTH = 20
+
     def get_completions(
         self, document: Document, _complete_event: CompleteEvent
     ) -> Iterable[Completion]:
         """Get completions for @file references.
 
-        Favors file matches before directory matches and supports fuzzy
-        matching for near-miss filenames. Order:
+        Favors file matches before directory matches while allowing fuzzy
+        near-miss suggestions. Ordering:
           exact files > fuzzy files > exact dirs > fuzzy dirs
         """
         # Get the word before cursor
@@ -108,7 +123,7 @@ class FileReferenceCompleter(Completer):
             dir_path = candidate_dir
             prefix = ""
 
-        # Get matching files with fuzzy support
+        # Get matching files using prefix matching
         try:
             if os.path.exists(dir_path) and os.path.isdir(dir_path):
                 items = sorted(os.listdir(dir_path))
@@ -131,37 +146,44 @@ class FileReferenceCompleter(Completer):
                 exact_files = [f for f in files if f.lower().startswith(prefix_lower)]
                 exact_dirs = [d for d in dirs if d.lower().startswith(prefix_lower)]
 
-                # Fuzzy matches (exclude items already matched exactly)
                 fuzzy_file_candidates = [f for f in files if f not in exact_files]
                 fuzzy_dir_candidates = [d for d in dirs if d not in exact_dirs]
 
-                fuzzy_files = (
-                    find_fuzzy_matches(prefix, fuzzy_file_candidates, n=10, cutoff=0.75)
-                    if prefix
-                    else []
-                )
-                fuzzy_dirs = (
-                    find_fuzzy_matches(prefix, fuzzy_dir_candidates, n=10, cutoff=0.75)
-                    if prefix
-                    else []
+                fuzzy_files = self._collect_fuzzy_matches(prefix, fuzzy_file_candidates)
+                fuzzy_dirs = self._collect_fuzzy_matches(prefix, fuzzy_dir_candidates)
+
+                ordered: List[tuple[str, str, bool]] = (
+                    [("file", name, False) for name in exact_files]
+                    + [("file", name, False) for name in fuzzy_files]
+                    + [("dir", name, False) for name in exact_dirs]
+                    + [("dir", name, False) for name in fuzzy_dirs]
                 )
 
-                # Compose ordered results
-                ordered: List[tuple[str, str]] = (
-                    [("file", name) for name in exact_files]
-                    + [("file", name) for name in fuzzy_files]
-                    + [("dir", name) for name in exact_dirs]
-                    + [("dir", name) for name in fuzzy_dirs]
+                local_seen: Set[str] = {
+                    os.path.normpath(os.path.join(dir_path, name))
+                    if dir_path != "."
+                    else os.path.normpath(name)
+                    for name in (*exact_files, *fuzzy_files, *exact_dirs, *fuzzy_dirs)
+                }
+
+                global_matches = self._collect_global_path_matches(
+                    prefix,
+                    dir_path,
+                    local_seen,
                 )
+                ordered += global_matches
 
                 start_position = -len(path_part)
-                for kind, name in ordered:
-                    full_path = os.path.join(dir_path, name) if dir_path != "." else name
+                for kind, name, is_global in ordered:
+                    if is_global:
+                        full_path = name
+                        display = name + "/" if kind == "dir" else name
+                    else:
+                        full_path = os.path.join(dir_path, name) if dir_path != "." else name
+                        display = name + "/" if kind == "dir" else name
                     if kind == "dir":
-                        display = name + "/"
                         completion_text = full_path + "/"
                     else:
-                        display = name
                         completion_text = full_path
 
                     yield Completion(
@@ -174,6 +196,117 @@ class FileReferenceCompleter(Completer):
             # Silently ignore inaccessible directories
             pass
 
+    @classmethod
+    # CLAUDE_ANCHOR[key=1f0911c7] Prompt Toolkit fuzzy matching consolidates file and directory suggestions
+    def _collect_fuzzy_matches(cls, prefix: str, candidates: Sequence[str]) -> List[str]:
+        """Return fuzzy-ordered candidate names respecting configured limit."""
+
+        if not prefix or not candidates:
+            return []
+
+        fuzzy_completer = FuzzyWordCompleter(candidates, WORD=cls._FUZZY_WORD_MODE)
+        prefix_document = Document(text=prefix)
+        event = CompleteEvent(completion_requested=True)
+        matches: List[str] = []
+        for completion in fuzzy_completer.get_completions(prefix_document, event):
+            candidate = completion.text
+            if candidate in candidates and candidate not in matches:
+                matches.append(candidate)
+            if len(matches) >= cls._FUZZY_RESULT_LIMIT:
+                break
+        return matches
+
+    @classmethod
+    def _collect_global_path_matches(
+        cls,
+        prefix: str,
+        current_dir: str,
+        seen: Set[str],
+    ) -> List[Tuple[str, str, bool]]:
+        """Return global fuzzy matches outside the current directory."""
+
+        if not prefix:
+            return []
+
+        roots = cls._global_roots()
+        if not roots:
+            return []
+
+        event = CompleteEvent(completion_requested=True)
+        document = Document(text=prefix)
+        matches: List[Tuple[str, str, bool]] = []
+        normalized_current = os.path.normpath(current_dir or ".")
+
+        for root in roots:
+            normalized_root = os.path.normpath(root)
+            if normalized_root == normalized_current:
+                continue
+
+            completer = FuzzyCompleter(
+                PathCompleter(only_directories=False, get_paths=lambda root=normalized_root: [root])
+            )
+            for completion in completer.get_completions(document, event):
+                candidate_path = os.path.normpath(os.path.join(normalized_root, completion.text))
+                if candidate_path in seen:
+                    continue
+
+                seen.add(candidate_path)
+                normalized_display = os.path.relpath(candidate_path, start=".").replace("\\", "/")
+                matches.append(
+                    (
+                        "dir" if os.path.isdir(candidate_path) else "file",
+                        normalized_display,
+                        True,
+                    )
+                )
+                if len(matches) >= cls._FUZZY_RESULT_LIMIT:
+                    return matches
+
+        return matches
+
+    @classmethod
+    def _global_roots(cls) -> List[str]:
+        """Compute cached directory list for global fuzzy lookups."""
+
+        if cls._GLOBAL_ROOT_CACHE is not None:
+            return cls._GLOBAL_ROOT_CACHE
+
+        roots: List[str] = []
+        limit = cls._GLOBAL_ROOT_LIMIT
+        max_depth = cls._GLOBAL_MAX_DEPTH
+
+        for root, dirs, _ in os.walk(".", topdown=True):
+            rel_root = os.path.relpath(root, ".")
+            normalized = "." if rel_root == "." else rel_root
+            depth = 0 if normalized == "." else normalized.count(os.sep) + 1
+            if depth > max_depth:
+                dirs[:] = []
+                continue
+
+            if should_skip_directory(normalized):
+                dirs[:] = []
+                continue
+
+            if dirs:
+                rel_dir = os.path.relpath(root, ".")
+                base = "." if rel_dir == "." else rel_dir
+                filtered_dirs = []
+                for directory in dirs:
+                    candidate = directory if base == "." else f"{base}/{directory}"
+                    if should_skip_directory(candidate):
+                        continue
+                    filtered_dirs.append(directory)
+                dirs[:] = filtered_dirs
+
+            if normalized not in roots:
+                roots.append(normalized)
+
+            if len(roots) >= limit:
+                break
+
+        cls._GLOBAL_ROOT_CACHE = prioritize_roots(roots)
+        return cls._GLOBAL_ROOT_CACHE
+
 
 class ModelCompleter(Completer):
     """Completer for model names in /model command."""

tunacode/ui/path_heuristics.py

@@ -0,0 +1,89 @@
+"""Shared heuristics for prioritizing and skipping project paths."""
+
+from __future__ import annotations
+
+from typing import Iterable, List, Sequence
+
+# CLAUDE_ANCHOR[key=0b3f320e] Cross-ecosystem skip directory defaults for FileReferenceCompleter global roots
+DEFAULT_SKIP_DIRECTORY_NAMES: Sequence[str] = (
+    ".git",
+    ".hg",
+    ".svn",
+    ".idea",
+    ".vscode",
+    ".venv",
+    "venv",
+    ".uv_cache",
+    "node_modules",
+    "dist",
+    "build",
+    "out",
+    "target",
+    # CLAUDE_ANCHOR[key=6fd59413] Skip list includes __pycache__ to avoid noisy Python build artifacts in suggestions
+    "vendor",
+    "__pycache__",
+    ".mypy_cache",
+    ".pytest_cache",
+    ".ruff_cache",
+    ".tox",
+    "coverage",
+    ".cache",
+    # CLAUDE_ANCHOR[key=2bcebd52] Skip heuristic checks every path component to prune nested junk directories such as __pycache__
+)
+
+DEFAULT_PRIORITY_PREFIXES: Sequence[str] = (
+    "src",
+    "app",
+    "lib",
+    "cmd",
+    "pkg",
+    "internal",
+    "include",
+    "components",
+    "tests",
+    "test",
+    "spec",
+    "examples",
+    "docs",
+    "documentation",
+)
+
+
+def prioritize_roots(roots: Iterable[str]) -> List[str]:
+    """Order project roots so high-signal directories surface first."""
+
+    ordered: List[str] = []
+    seen = set()
+
+    for root in roots:
+        if root == "." and root not in seen:
+            ordered.append(root)
+            seen.add(root)
+
+    for prefix in DEFAULT_PRIORITY_PREFIXES:
+        for root in roots:
+            if root in seen:
+                continue
+            normalized = root.replace("\\", "/")
+            if normalized == prefix or normalized.startswith(f"{prefix}/"):
+                ordered.append(root)
+                seen.add(root)
+
+    for root in roots:
+        if root in seen:
+            continue
+        ordered.append(root)
+        seen.add(root)
+
+    return ordered
+
+
+def should_skip_directory(path: str) -> bool:
+    """Return True when any component of the path matches skip heuristics."""
+
+    if not path or path == ".":
+        return False
+
+    normalized = path.replace("\\", "/")
+    components = normalized.split("/")
+    return any(component in DEFAULT_SKIP_DIRECTORY_NAMES for component in components)

{tunacode_cli-0.0.76.4.dist-info → tunacode_cli-0.0.76.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tunacode-cli
-Version: 0.0.76.4
+Version: 0.0.76.6
 Summary: Your agentic CLI developer.
 Project-URL: Homepage, https://tunacode.xyz/
 Project-URL: Repository, https://github.com/alchemiststudiosDOTai/tunacode

{tunacode_cli-0.0.76.4.dist-info → tunacode_cli-0.0.76.6.dist-info}/RECORD

@@ -1,16 +1,16 @@
 tunacode/__init__.py,sha256=yUul8igNYMfUrHnYfioIGAqvrH8b5BKiO_pt1wVnmd0,119
-tunacode/constants.py,sha256=UjCi8qEonZUeA-UkPukT3l2ZoQeD43gmLCValHmJ6gs,6170
+tunacode/constants.py,sha256=PN8RpED4DoJ5YbkRBo9payGmF448TLoROc9IFvc5HDA,6170
 tunacode/context.py,sha256=YtfRjUiqsSkk2k9Nn_pjb_m-AXyh6XcOBOJWtFI0wVw,2405
 tunacode/exceptions.py,sha256=m80njR-LqBXhFAEOPqCE7N2QPU4Fkjlf_f6CWKO0_Is,8479
 tunacode/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tunacode/setup.py,sha256=F1E4zHVnbByu_Uo6AhCJ-W-lIGF_gV6kB84HLAGLmVY,2103
 tunacode/types.py,sha256=xNpDRjIRYg4qGNbl3EG8B13CWAWBoob9ekVm8_6dvnc,10496
 tunacode/cli/__init__.py,sha256=zgs0UbAck8hfvhYsWhWOfBe5oK09ug2De1r4RuQZREA,55
-tunacode/cli/main.py,sha256=ZzFjLnn6YTYRrcgt7DfyqrxIPM220kBF2xV9rwF1BmA,3439
+tunacode/cli/main.py,sha256=MAKPFA4kGSFciqMdxnyp2r9XzVp8TfxvK6ztt7dvjwM,3445
 tunacode/cli/repl.py,sha256=QBw05NNypxuTYoV51FVoTfujJfiOTCIYzAr_1uoi0YA,23515
 tunacode/cli/commands/__init__.py,sha256=J7MZofTaSgspAKP64OavPukj4l53qvkv_-sCfYEUi10,1794
 tunacode/cli/commands/base.py,sha256=Ge_lNQA-GDfcb1Ap1oznCH3UrifBiHH3bA9DNL-tCDw,2519
-tunacode/cli/commands/registry.py,sha256=qey9iqLL-gJF2zWATtY-AjNgE9zfA7197MuJpHVf_C0,15433
+tunacode/cli/commands/registry.py,sha256=J2zS2QZmVaUyOA6GEgYwKqh1bZ9QBbsuuxMYniF7YSA,15139
 tunacode/cli/commands/template_shortcut.py,sha256=ApYTPkDVBRaLxa7rWaPrsGcJdkR7eg09k18KyTjYg_E,3447
 tunacode/cli/commands/implementations/__init__.py,sha256=dFczjIqCJTPrsSycD6PZYnp5_cIEQEGgKr0Y14MRGjs,1088
 tunacode/cli/commands/implementations/command_reload.py,sha256=GyjeKvJbgE4VYkaasGajspdk9wffumZMNLzfCUeNazM,1555
@@ -124,7 +124,7 @@ tunacode/tutorial/content.py,sha256=qaQewFwXtKKEmzLH-4oMECGAa4Z4nd1qh2HfRWLpwyk,
 tunacode/tutorial/manager.py,sha256=ZgkzSC6ZtYSDq5Ce_TfYk9O9cvgFSL-pXrLZb7_HStM,6309
 tunacode/tutorial/steps.py,sha256=l2bbRVJuYlC186A-U1TIoMPBtLl4j053h4Wlzo1VO8c,4393
 tunacode/ui/__init__.py,sha256=aRNE2pS50nFAX6y--rSGMNYwhz905g14gRd6g4BolYU,13
-tunacode/ui/completers.py,sha256=O5wAlo9cufV2VWbFKMWzZeXRqptdS4CwK6wok1DdDak,14786
+tunacode/ui/completers.py,sha256=2VLVu5Nsl9LT34KcZ6zsKiEfZkgzVNcbt4vx6jw8MpQ,19548
 tunacode/ui/config_dashboard.py,sha256=FhfWwEzPTNjvornTb0njxv_o2SavoEW4EXqyOCrbqk0,21657
 tunacode/ui/console.py,sha256=HfE30vUy8ebXCobP7psFNJc17-dvH6APChg2tbi7aTw,2632
 tunacode/ui/constants.py,sha256=A76B_KpM8jCuBYRg4cPmhi8_j6LLyWttO7_jjv47r3w,421
@@ -136,6 +136,7 @@ tunacode/ui/logging_compat.py,sha256=5v6lcjVaG1CxdY1Zm9FAGr9H7Sy-tP6ihGfhP-5YvAY
 tunacode/ui/model_selector.py,sha256=07kV9v0VWFgDapiXTz1_BjzHF1AliRq24I9lDq-hmHc,13426
 tunacode/ui/output.py,sha256=ybVVutiilOQcULtA1zjjs_tTu5okwxHFp2MHtNz3s2E,6767
 tunacode/ui/panels.py,sha256=6XGOeax4m-yQvwP1iML67GK10AKlDLD46dB522gcNPU,17236
+tunacode/ui/path_heuristics.py,sha256=SkhGaM8WCRuK86vLwypbfhtI81PrXtOsWoz-P0CTsmQ,2221
 tunacode/ui/prompt_manager.py,sha256=HUL6443pFPb41uDAnAKD-sZsrWd_VhWYRGwvrFH_9SI,5618
 tunacode/ui/tool_descriptions.py,sha256=vk61JPIXy7gHNfJ--77maXgK6WwNwxqY47QYsw_a2uw,4126
 tunacode/ui/tool_ui.py,sha256=MVmBLXx6OTJVFLl58SpoW0KoStOrbAY9sc6XXMKgWtQ,7216
@@ -147,7 +148,6 @@ tunacode/utils/bm25.py,sha256=fd59YQXovC8rXwZrdoqIAfFrLn_WCVjzCh0pkU22APE,1966
 tunacode/utils/config_comparator.py,sha256=iMShhYCKlo0dXycbfpRu5rj3ckT460FoDvkbr5_-yTY,12879
 tunacode/utils/diff_utils.py,sha256=V9QqQ0q4MfabVTnWptF3IXDp3estnfOKcJtDe_Sj14I,2372
 tunacode/utils/file_utils.py,sha256=84g-MQRzmBI2aG_CuXsDl2OhvvWoSL7YdL5Kz_UKSwk,979
-tunacode/utils/fuzzy_utils.py,sha256=Dl2C4ksNVfqdhjn-bVur4_JFiPkQXYerCjR-EOmtmRI,1140
 tunacode/utils/import_cache.py,sha256=q_xjJbtju05YbFopLDSkIo1hOtCx3DOTl3GQE5FFDgs,295
 tunacode/utils/json_utils.py,sha256=cMVctSwwV9Z1c-rZdj6UuOlZwsUPSTF5oUruP6uPix0,6470
 tunacode/utils/message_utils.py,sha256=V4MrZZPmwO22_MVGupMqtE5ltQEBwaSIqGD5LEb_bLw,1050
@@ -159,8 +159,8 @@ tunacode/utils/system.py,sha256=J8KqJ4ZqQrNSnM5rrJxPeMk9z2xQQp6dWtI1SKBY1-0,1112
 tunacode/utils/text_utils.py,sha256=HAwlT4QMy41hr53cDbbNeNo05MI461TpI9b_xdIv8EY,7288
 tunacode/utils/token_counter.py,sha256=dmFuqVz4ywGFdLfAi5Mg9bAGf8v87Ek-mHU-R3fsYjI,2711
 tunacode/utils/user_configuration.py,sha256=OA-L0BgWNbf9sWpc8lyivgLscwJdpdI8TAYbe0wRs1s,4836
-tunacode_cli-0.0.76.4.dist-info/METADATA,sha256=2QbpnZ143R18XCvsBBeke9uhJ2wd7RL2hy1HPPdnODQ,8913
-tunacode_cli-0.0.76.4.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-tunacode_cli-0.0.76.4.dist-info/entry_points.txt,sha256=hbkytikj4dGu6rizPuAd_DGUPBGF191RTnhr9wdhORY,51
-tunacode_cli-0.0.76.4.dist-info/licenses/LICENSE,sha256=Btzdu2kIoMbdSp6OyCLupB1aRgpTCJ_szMimgEnpkkE,1056
-tunacode_cli-0.0.76.4.dist-info/RECORD,,
+tunacode_cli-0.0.76.6.dist-info/METADATA,sha256=qXHrlK7J8ftroVTJyUoF-6dRHc2YZ0LsdGPZ-Zm6qN0,8913
+tunacode_cli-0.0.76.6.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+tunacode_cli-0.0.76.6.dist-info/entry_points.txt,sha256=hbkytikj4dGu6rizPuAd_DGUPBGF191RTnhr9wdhORY,51
+tunacode_cli-0.0.76.6.dist-info/licenses/LICENSE,sha256=Btzdu2kIoMbdSp6OyCLupB1aRgpTCJ_szMimgEnpkkE,1056
+tunacode_cli-0.0.76.6.dist-info/RECORD,,

tunacode/utils/fuzzy_utils.py

@@ -1,33 +0,0 @@
-"""Shared fuzzy matching utilities.
-
-Minimal helper to provide consistent fuzzy matching behavior across
-components (commands, file completers, etc.) without introducing new
-dependencies. Reuses difflib.get_close_matches with a default cutoff of 0.75
-matching the command registry behavior.
-"""
-
-from difflib import get_close_matches
-from typing import List, Sequence
-
-
-def find_fuzzy_matches(
-    query: str,
-    choices: Sequence[str],
-    *,
-    n: int = 5,
-    cutoff: float = 0.75,
-) -> List[str]:
-    """Return up to ``n`` fuzzy matches from ``choices`` for ``query``.
-
-    The return order is the order produced by ``difflib.get_close_matches``.
-    Matching is case-insensitive; original casing is preserved in the result.
-    """
-    if not query or not choices:
-        return []
-
-    # Map lower-case to original to do case-insensitive matching while
-    # returning original items.
-    lower_to_original = {c.lower(): c for c in choices}
-    candidates = list(lower_to_original.keys())
-    matches_lower = get_close_matches(query.lower(), candidates, n=n, cutoff=cutoff)
-    return [lower_to_original[m] for m in matches_lower]