iac-code 0.1.0__py3-none-any.whl

iac_code/ui/spinner.py

@@ -0,0 +1,112 @@
+"""Spinner for Rich Live — single warm color.
+
+Pure data renderer — no timers. The caller controls refresh rate by
+calling render() in a loop.
+"""
+
+from __future__ import annotations
+
+import random
+import time
+
+from rich.text import Text
+
+# Animation frame sequences
+SPINNER_DOTS = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"]
+
+# Spinner color — warm orange
+SPINNER_COLOR = "rgb(215,119,87)"
+
+# Frame interval for spinner character rotation
+_FRAME_INTERVAL = 0.08
+
+# Verbs displayed in spinner while processing (present participle)
+# These are i18n keys — call _() on them before display.
+SPINNER_VERBS = [
+    "Thinking",
+    "Processing",
+    "Working",
+]
+
+# Past-tense verbs for turn completion messages (works with "for Xs")
+# These are i18n keys — call _() on them before display.
+COMPLETION_VERBS = [
+    "Thought",
+    "Processed",
+    "Worked",
+]
+
+
+def _format_elapsed(seconds: float) -> str:
+    if seconds < 60:
+        return f"{seconds:.0f}s"
+    minutes = int(seconds // 60)
+    secs = int(seconds % 60)
+    return f"{minutes}m {secs}s"
+
+
+def random_spinner_verb() -> str:
+    """Pick a random translated spinner verb for in-progress display."""
+    from iac_code.i18n import _
+
+    # NOTE: explicit _() calls for pybabel extraction
+    _("Thinking")
+    _("Processing")
+    _("Working")
+    return _(random.choice(SPINNER_VERBS))
+
+
+def random_completion_verb() -> str:
+    """Pick a random translated past-tense verb for completion display."""
+    from iac_code.i18n import _
+
+    # NOTE: explicit _() calls for pybabel extraction
+    _("Thought")
+    _("Processed")
+    _("Worked")
+    return _(random.choice(COMPLETION_VERBS))
+
+
+class ShimmerSpinner:
+    """Animated spinner with warm single-color style.
+
+    Usage::
+
+        spinner = ShimmerSpinner()
+        with Live(spinner.render(), console=console, refresh_per_second=20) as live:
+            while working:
+                live.update(spinner.render())
+    """
+
+    def __init__(self, status: str | None = None) -> None:
+        self._status = status or (random_spinner_verb() + "...")
+        self._start_time = time.monotonic()
+
+    @property
+    def elapsed(self) -> float:
+        """Seconds since this spinner was created."""
+        return time.monotonic() - self._start_time
+
+    def render(self) -> Text:
+        """Produce a single frame as a Rich Text object."""
+        now = time.monotonic()
+        elapsed = now - self._start_time
+
+        # Spinner character (rotates based on wall clock)
+        frame_idx = int(now / _FRAME_INTERVAL) % len(SPINNER_DOTS)
+        frame = SPINNER_DOTS[frame_idx]
+
+        text = Text()
+
+        # Spinner character + status in warm orange
+        style = f"bold {SPINNER_COLOR}"
+        text.append(f"{frame} ", style=style)
+        text.append(self._status, style=style)
+
+        # Elapsed time in dim
+        text.append(f" ({_format_elapsed(elapsed)})", style="dim")
+
+        return text
+
+    def update_status(self, status: str) -> None:
+        self._status = status

iac_code/ui/suggestions/aggregator.py

@@ -0,0 +1,171 @@
+"""Suggestion aggregator that coordinates multiple providers."""
+
+from __future__ import annotations
+
+from iac_code.ui.suggestions.token_extractor import TokenExtractor
+from iac_code.ui.suggestions.types import SuggestionItem, SuggestionProvider
+
+OVERLAY_MAX_ITEMS = 5
+
+
+class SuggestionAggregator:
+    """Aggregates suggestions from multiple providers based on the current input."""
+
+    def __init__(self, providers: list[SuggestionProvider]) -> None:
+        self._providers = providers
+        self._extractor = TokenExtractor()
+        self._suggestions: list[SuggestionItem] = []
+        self._selected_index: int = 0
+        self._token_text: str = ""
+        self._token_start: int = 0
+        self._token_end: int = 0
+        self._active: bool = False
+
+    def update(self, text: str, cursor_pos: int) -> None:
+        """Extract a token from text and dispatch to matching providers."""
+        token = self._extractor.extract(text, cursor_pos)
+
+        if token is None:
+            self.dismiss()
+            return
+
+        # Find providers that handle this trigger
+        matching = [p for p in self._providers if p.trigger == token.trigger]
+
+        if not matching:
+            self.dismiss()
+            return
+
+        # Collect suggestions from all matching providers
+        all_items: list[SuggestionItem] = []
+        for provider in matching:
+            items = provider.provide(token)
+            all_items.extend(items)
+
+        # Sort by score descending
+        all_items.sort(key=lambda i: i.score, reverse=True)
+        self._suggestions = all_items
+        self._selected_index = 0
+        self._token_text = token.text
+        self._token_start = token.start
+        self._token_end = token.end
+        self._active = True
+
+    @property
+    def suggestions(self) -> list[SuggestionItem]:
+        """The full list of suggestions."""
+        return self._suggestions
+
+    @property
+    def visible_suggestions(self) -> list[SuggestionItem]:
+        """The visible window of suggestions (at most OVERLAY_MAX_ITEMS)."""
+        if len(self._suggestions) <= OVERLAY_MAX_ITEMS:
+            return self._suggestions
+        start = self._visible_start
+        return self._suggestions[start : start + OVERLAY_MAX_ITEMS]
+
+    @property
+    def visible_selected_index(self) -> int:
+        """The selected index relative to the visible window."""
+        return self._selected_index - self._visible_start
+
+    @property
+    def _visible_start(self) -> int:
+        """Calculate the start of the visible window based on selected index."""
+        n = len(self._suggestions)
+        if n <= OVERLAY_MAX_ITEMS:
+            return 0
+        # Keep selected item within the visible window
+        start = max(0, self._selected_index - OVERLAY_MAX_ITEMS + 1)
+        start = min(start, n - OVERLAY_MAX_ITEMS)
+        return start
+
+    @property
+    def has_more_above(self) -> bool:
+        """Whether there are items above the visible window."""
+        return self._visible_start > 0
+
+    @property
+    def has_more_below(self) -> bool:
+        """Whether there are items below the visible window."""
+        n = len(self._suggestions)
+        return self._visible_start + OVERLAY_MAX_ITEMS < n
+
+    @property
+    def ghost_text(self) -> str:
+        """Best match completion minus the typed portion.
+
+        Returns the part of the top suggestion's completion that extends
+        beyond the already-typed text. When the user has typed the full
+        command name and the selected item declares an ``arg_hint``, the
+        hint is appended as visual-only ghost text (Tab won't insert it).
+        """
+        if not self._suggestions:
+            return ""
+
+        selected = self._suggestions[self._selected_index]
+        typed = self._token_text
+        completion = selected.completion
+
+        if not completion.lower().startswith(typed.lower()):
+            return ""
+
+        base = completion[len(typed) :]
+
+        arg_hint = selected.arg_hint
+        if arg_hint:
+            name_only = completion.rstrip()
+            if typed.lower() == name_only.lower():
+                return base + arg_hint
+        return base
+
+    @property
+    def selected_index(self) -> int:
+        """The currently selected suggestion index."""
+        return self._selected_index
+
+    def move_selection(self, delta: int) -> None:
+        """Move the selection by delta steps, wrapping around."""
+        n = len(self._suggestions)
+        if n == 0:
+            return
+        self._selected_index = (self._selected_index + delta) % n
+
+    def accept_selected(self) -> tuple[str, int, int] | None:
+        """Accept the currently selected suggestion.
+
+        Returns (completion_text, token_start, token_end) or None if nothing selected.
+        """
+        if not self._suggestions or not self._active:
+            return None
+
+        item = self._suggestions[self._selected_index]
+        result = (item.completion, self._token_start, self._token_end)
+        self.dismiss()
+        return result
+
+    def accept_ghost_text(self) -> tuple[str, int, int] | None:
+        """Accept the ghost text (top suggestion completion).
+
+        Returns (completion_text, token_start, token_end) or None if no ghost text.
+        """
+        if not self._suggestions or not self._active:
+            return None
+
+        ghost = self.ghost_text
+        if not ghost:
+            return None
+
+        item = self._suggestions[self._selected_index]
+        result = (item.completion, self._token_start, self._token_end)
+        self.dismiss()
+        return result
+
+    def dismiss(self) -> None:
+        """Clear all suggestions and reset state."""
+        self._suggestions = []
+        self._selected_index = 0
+        self._token_text = ""
+        self._token_start = 0
+        self._token_end = 0
+        self._active = False

iac_code/ui/suggestions/command_provider.py

@@ -0,0 +1,43 @@
+"""Command suggestion provider."""
+
+from __future__ import annotations
+
+from iac_code.commands.registry import CommandRegistry, LocalCommand
+from iac_code.ui.suggestions.types import CompletionToken, SuggestionItem, SuggestionProvider
+
+
+class CommandProvider(SuggestionProvider):
+    """Provides slash-command suggestions from a CommandRegistry."""
+
+    trigger = "/"
+
+    def __init__(self, registry: CommandRegistry) -> None:
+        self._registry = registry
+
+    def provide(self, token: CompletionToken) -> list[SuggestionItem]:
+        """Return suggestions for the given completion token."""
+        # Strip the leading "/" to get the query
+        query = token.text[1:] if token.text.startswith("/") else token.text
+
+        matches = self._registry.fuzzy_search(query)
+
+        items: list[SuggestionItem] = []
+        for match in matches:
+            cmd = match.command
+            name = match.name
+            completion = f"/{name} "
+            arg_hint = cmd.arg_hint if isinstance(cmd, LocalCommand) else None
+            items.append(
+                SuggestionItem(
+                    id=f"cmd:{cmd.name}",
+                    display_text=name,
+                    completion=completion,
+                    description=cmd.description,
+                    icon="/",
+                    source="command",
+                    score=float(-match.priority * 1000 - match.score),
+                    arg_hint=arg_hint,
+                )
+            )
+
+        return items

iac_code/ui/suggestions/directory_provider.py

@@ -0,0 +1,95 @@
+"""Directory suggestion provider."""
+
+from __future__ import annotations
+
+import os
+
+from iac_code.ui.components.fuzzy_picker import fuzzy_match
+from iac_code.ui.suggestions.file_provider import EXCLUDE_DIRS
+from iac_code.ui.suggestions.types import CompletionToken, SuggestionItem, SuggestionProvider
+
+
+class DirectoryProvider(SuggestionProvider):
+    """Suggests directory entries (dirs + files) matching an @-prefixed query.
+
+    Unlike FileProvider which indexes the entire tree, DirectoryProvider lists
+    entries in the directory that corresponds to the query path prefix, similar
+    to shell tab-completion behaviour.
+    """
+
+    trigger = "@"
+
+    def __init__(self, root_dir: str) -> None:
+        self._root_dir = os.path.abspath(root_dir)
+
+    def _list_entries(self, dir_path: str) -> list[tuple[str, bool]]:
+        """List (name, is_dir) entries in dir_path, excluding hidden/excluded dirs."""
+        entries: list[tuple[str, bool]] = []
+        try:
+            for entry in os.scandir(dir_path):
+                name = entry.name
+                is_dir = entry.is_dir(follow_symlinks=False)
+                # Skip hidden entries and excluded directories
+                if name.startswith("."):
+                    continue
+                if is_dir and name in EXCLUDE_DIRS:
+                    continue
+                entries.append((name, is_dir))
+        except PermissionError:
+            pass
+        entries.sort(key=lambda e: (not e[1], e[0].lower()))
+        return entries
+
+    def provide(self, token: CompletionToken) -> list[SuggestionItem]:
+        """Return directory-listing suggestions for the given token."""
+        # Strip the leading "@"
+        query = token.text[1:] if token.text.startswith("@") else token.text
+
+        # Split query into directory prefix and filename fragment
+        # e.g. "src/ui/inp" → dir_prefix="src/ui", fragment="inp"
+        # e.g. "src/" → dir_prefix="src", fragment=""
+        # e.g. "src" → dir_prefix="", fragment="src"
+        if "/" in query:
+            last_slash = query.rfind("/")
+            dir_prefix = query[:last_slash]
+            fragment = query[last_slash + 1 :]
+        else:
+            dir_prefix = ""
+            fragment = query
+
+        # Resolve the directory to list
+        if dir_prefix:
+            list_dir = os.path.join(self._root_dir, dir_prefix)
+        else:
+            list_dir = self._root_dir
+
+        entries = self._list_entries(list_dir)
+
+        items: list[SuggestionItem] = []
+        for name, is_dir in entries:
+            if fragment:
+                score = fuzzy_match(fragment, name)
+                if score is None:
+                    continue
+            else:
+                score = 0.0
+
+            if dir_prefix:
+                rel_path = f"{dir_prefix}/{name}"
+            else:
+                rel_path = name
+
+            completion_suffix = "/" if is_dir else ""
+            items.append(
+                SuggestionItem(
+                    id=f"dir:{rel_path}",
+                    display_text=rel_path + completion_suffix,
+                    completion=f"@{rel_path}{completion_suffix}",
+                    description="directory" if is_dir else "",
+                    icon="◇",
+                    source="directory",
+                    score=score,
+                )
+            )
+
+        return items

iac_code/ui/suggestions/file_provider.py

@@ -0,0 +1,121 @@
+"""File suggestion provider."""
+
+from __future__ import annotations
+
+import os
+import time
+
+from iac_code.ui.components.fuzzy_picker import fuzzy_match
+from iac_code.ui.suggestions.types import CompletionToken, SuggestionItem, SuggestionProvider
+
+EXCLUDE_DIRS: frozenset[str] = frozenset(
+    {
+        ".git",
+        ".svn",
+        ".hg",
+        ".bzr",
+        ".jj",
+        ".sl",
+        ".vscode",
+        ".idea",
+        ".claude",
+        "__pycache__",
+        ".venv",
+        "venv",
+        ".tox",
+        ".mypy_cache",
+        ".ruff_cache",
+        ".pytest_cache",
+        ".eggs",
+        ".nox",
+        "node_modules",
+        ".next",
+        ".nuxt",
+        "bower_components",
+        "dist",
+        "build",
+        "_build",
+        ".build",
+        "target",
+        ".cache",
+        ".npm",
+        ".yarn",
+    }
+)
+
+MAX_INDEX_FILES = 10_000
+INDEX_STALE_SECONDS = 30
+
+
+def _should_exclude_dir(name: str) -> bool:
+    """Return True if this directory should be excluded from indexing."""
+    if name in EXCLUDE_DIRS:
+        return True
+    # Exclude *.egg-info directories
+    if name.endswith(".egg-info"):
+        return True
+    return False
+
+
+class FileProvider(SuggestionProvider):
+    """Suggests files from the project tree matching an @-prefixed query."""
+
+    trigger = "@"
+
+    def __init__(self, root_dir: str) -> None:
+        self._root_dir = os.path.abspath(root_dir)
+        self._index: list[str] = []  # relative paths
+        self._index_time: float = 0.0
+
+    def _needs_refresh(self) -> bool:
+        return (time.monotonic() - self._index_time) > INDEX_STALE_SECONDS
+
+    def _build_index(self) -> None:
+        """Walk the directory tree and build the file index."""
+        files: list[str] = []
+        for dirpath, dirnames, filenames in os.walk(self._root_dir):
+            # Prune excluded dirs in-place so os.walk won't descend into them
+            dirnames[:] = [d for d in dirnames if not _should_exclude_dir(d)]
+            for fname in filenames:
+                abs_path = os.path.join(dirpath, fname)
+                rel_path = os.path.relpath(abs_path, self._root_dir)
+                files.append(rel_path)
+                if len(files) >= MAX_INDEX_FILES:
+                    break
+            if len(files) >= MAX_INDEX_FILES:
+                break
+
+        self._index = files
+        self._index_time = time.monotonic()
+
+    def provide(self, token: CompletionToken) -> list[SuggestionItem]:
+        """Return file suggestions for the given token."""
+        if self._needs_refresh():
+            self._build_index()
+
+        # Strip the leading "@" to get the query
+        query = token.text[1:] if token.text.startswith("@") else token.text
+
+        scored: list[tuple[float, str]] = []
+        for rel_path in self._index:
+            score = fuzzy_match(query, rel_path) if query else 0.0
+            if score is not None:
+                scored.append((score, rel_path))
+
+        scored.sort(key=lambda x: x[0], reverse=True)
+
+        items: list[SuggestionItem] = []
+        for score, rel_path in scored:
+            items.append(
+                SuggestionItem(
+                    id=f"file:{rel_path}",
+                    display_text=rel_path,
+                    completion=f"@{rel_path}",
+                    description="",
+                    icon="+",
+                    source="file",
+                    score=score,
+                )
+            )
+
+        return items

iac_code/ui/suggestions/shell_history_provider.py

@@ -0,0 +1,108 @@
+"""Shell history suggestion provider."""
+
+from __future__ import annotations
+
+import os
+
+from iac_code.ui.suggestions.types import CompletionToken, SuggestionItem, SuggestionProvider
+
+
+def _detect_history_path() -> str | None:
+    """Detect the shell history file path from the SHELL environment variable."""
+    shell = os.environ.get("SHELL", "")
+    home = os.path.expanduser("~")
+
+    if "zsh" in shell:
+        candidate = os.path.join(home, ".zsh_history")
+    elif "bash" in shell:
+        candidate = os.path.join(home, ".bash_history")
+    else:
+        # Fallback: try zsh first, then bash
+        zsh = os.path.join(home, ".zsh_history")
+        bash = os.path.join(home, ".bash_history")
+        if os.path.exists(zsh):
+            return zsh
+        if os.path.exists(bash):
+            return bash
+        return None
+
+    return candidate if os.path.exists(candidate) else None
+
+
+def _read_history(path: str) -> list[str]:
+    """Read history entries from a history file.
+
+    Handles both plain bash history and zsh extended history format.
+    Returns entries in file order (oldest first).
+    """
+    try:
+        with open(path, "rb") as f:
+            raw = f.read()
+    except OSError:
+        return []
+
+    # Decode, ignoring errors (history files can have mixed encodings)
+    text = raw.decode("utf-8", errors="replace")
+    lines = text.splitlines()
+
+    entries: list[str] = []
+    for line in lines:
+        # zsh extended_history format: ": <timestamp>:<elapsed>;<command>"
+        if line.startswith(": ") and ";" in line:
+            _, _, cmd = line.partition(";")
+            cmd = cmd.strip()
+            if cmd:
+                entries.append(cmd)
+        else:
+            line = line.strip()
+            if line:
+                entries.append(line)
+
+    return entries
+
+
+class ShellHistoryProvider(SuggestionProvider):
+    """Provides shell history suggestions for ! trigger."""
+
+    trigger = "!"
+
+    def __init__(self) -> None:
+        self._history_path: str | None = _detect_history_path()
+
+    def provide(self, token: CompletionToken) -> list[SuggestionItem]:
+        """Return shell history suggestions matching the query."""
+        if not self._history_path:
+            return []
+
+        # Strip the leading "!" to get the query
+        query = token.text[1:] if token.text.startswith("!") else token.text
+
+        entries = _read_history(self._history_path)
+
+        # Substring match, dedup, most recent first
+        seen: set[str] = set()
+        matched: list[str] = []
+
+        # Iterate in reverse so most recent entries come first
+        for entry in reversed(entries):
+            if entry in seen:
+                continue
+            if query.lower() in entry.lower():
+                seen.add(entry)
+                matched.append(entry)
+
+        items: list[SuggestionItem] = []
+        for i, entry in enumerate(matched):
+            items.append(
+                SuggestionItem(
+                    id=f"shell:{i}",
+                    display_text=entry,
+                    completion=f"!{entry}",
+                    description="",
+                    icon="↑",
+                    source="shell",
+                    score=float(len(matched) - i),
+                )
+            )
+
+        return items