aria-code 0.167.0__py3-none-win_amd64.whl

aria_code/ui/mentions.py

@@ -0,0 +1,206 @@
+"""One search behind "@": files, folders, market assets and saved resources.
+
+"@" opened on a list of kinds — file:, folder:, asset:, portfolio: … — and a
+file only appeared once a path character was typed, so attaching src/fx.py
+took "@", "file:", then the path. Codex's "@" goes straight to results across
+files, folders and plugins. Here "@fx" lists fx.py, test_fx.py and any asset,
+strategy or report that matches, each labelled with its kind; "@file:" and the
+other kind prefixes still narrow the list to one kind.
+
+The inserted text is the canonical reference (@file:src/fx.py, @asset:AAPL),
+so references.py resolves it unchanged. Nothing here imports prompt_toolkit.
+"""
+
+from __future__ import annotations
+
+import os
+import subprocess
+import time
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Iterable
+
+from aria_code.packages.aria_services.references import reference_search_roots
+
+# Directories a walk never enters when the workspace is not a git repository.
+_SKIP_DIRS = frozenset({
+    ".git", ".hg", ".svn", ".venv", "venv", "env", "node_modules", "__pycache__", ".mypy_cache",
+    ".pytest_cache", ".ruff_cache", ".tox", "dist", "build", ".next", ".idea", ".vscode", "target",
+})
+MAX_INDEXED_FILES = 20000
+INDEX_TTL_SECONDS = 30.0
+RESOURCE_KINDS = ("portfolio", "strategy", "dataset", "run", "report")
+# Within one match quality, this order breaks ties. A saved strategy or report
+# is named on purpose, so it ranks above the file behind it; an asset ranks
+# first only when the query is typed like a ticker ("@FX", not "@fx").
+_KIND_ORDER = {"strategy": 1, "portfolio": 2, "report": 3, "dataset": 4, "run": 5, "file": 6, "folder": 7}
+
+
+@dataclass(frozen=True)
+class Mention:
+    kind: str
+    value: str                 # what follows "kind:" — a path, a symbol, a name
+    score: int                 # lower is better
+    matched: tuple[int, ...] = ()   # positions in `label` to highlight
+
+    @property
+    def label(self) -> str:
+        return self.value + ("/" if self.kind == "folder" else "")
+
+    @property
+    def insert_text(self) -> str:
+        value = f'"{self.value}"' if any(ch.isspace() for ch in self.value) else self.value
+        return f"{self.kind}:{value}"
+
+
+def _match(query: str, text: str) -> tuple[int, tuple[int, ...]] | None:
+    """(score, positions) of query in text, or None. Case-insensitive."""
+    if not query:
+        return 50, ()
+    q, t = query.lower(), text.lower()
+    if t == q:
+        return 0, tuple(range(len(text)))
+    if t.startswith(q):
+        return 10, tuple(range(len(query)))
+    at = t.find(q)
+    if at >= 0:
+        return 20 + min(at, 9), tuple(range(at, at + len(query)))
+    positions, i = [], 0
+    for index, ch in enumerate(t):
+        if i < len(q) and ch == q[i]:
+            positions.append(index)
+            i += 1
+    if i == len(q):
+        spread = positions[-1] - positions[0]
+        return 40 + min(spread, 29), tuple(positions)
+    return None
+
+
+def _match_path(query: str, path: str) -> tuple[int, tuple[int, ...]] | None:
+    """Prefer the file name; fall back to the whole relative path."""
+    name_start = path.rfind("/") + 1
+    name_hit = _match(query, path[name_start:])
+    if name_hit is not None:
+        score, positions = name_hit
+        return score, tuple(name_start + p for p in positions)
+    path_hit = _match(query, path)
+    if path_hit is not None:
+        return path_hit[0] + 5, path_hit[1]
+    return None
+
+
+class MentionIndex:
+    """Searches everything "@" can attach, for one workspace."""
+
+    def __init__(self, workspace: Path | str, *, output_root: Path | str | None = None,
+                 symbols: Iterable[str] = ()):
+        self.workspace = Path(workspace).expanduser().resolve()
+        self.output_root = Path(output_root).expanduser().resolve() if output_root else None
+        self.symbols = sorted({str(s).upper() for s in symbols if str(s).strip()})
+        self._files: list[str] = []
+        self._indexed_at = 0.0
+
+    # ── the file list ────────────────────────────────────────────────────────
+    def files(self) -> list[str]:
+        """Workspace-relative file paths, .gitignore respected when in a repository."""
+        if not self._files or time.monotonic() - self._indexed_at > INDEX_TTL_SECONDS:
+            self._files = self._git_files() or self._walk_files()
+            self._indexed_at = time.monotonic()
+        return self._files
+
+    def _git_files(self) -> list[str]:
+        try:
+            done = subprocess.run(
+                ["git", "ls-files", "--cached", "--others", "--exclude-standard"],
+                cwd=self.workspace, capture_output=True, text=True, timeout=3,
+            )
+        except (OSError, subprocess.SubprocessError):
+            return []
+        if done.returncode != 0:
+            return []
+        return [line for line in done.stdout.splitlines() if line][:MAX_INDEXED_FILES]
+
+    def _walk_files(self) -> list[str]:
+        found: list[str] = []
+        for root, dirs, names in os.walk(self.workspace):
+            dirs[:] = sorted(d for d in dirs if d not in _SKIP_DIRS and not d.startswith("."))
+            rel_root = os.path.relpath(root, self.workspace)
+            for name in sorted(names):
+                if name.startswith("."):
+                    continue
+                found.append(name if rel_root == "." else f"{rel_root}/{name}".replace(os.sep, "/"))
+                if len(found) >= MAX_INDEXED_FILES:
+                    return found
+        return found
+
+    def folders(self) -> list[str]:
+        seen: dict[str, None] = {}
+        for path in self.files():
+            parts = path.split("/")[:-1]
+            for depth in range(1, len(parts) + 1):
+                seen["/".join(parts[:depth])] = None
+        return list(seen)
+
+    def recent_files(self, limit: int = 5) -> list[str]:
+        stamped = []
+        for path in self.files()[:MAX_INDEXED_FILES]:
+            try:
+                stamped.append((os.stat(self.workspace / path).st_mtime, path))
+            except OSError:
+                continue
+        return [path for _, path in sorted(stamped, reverse=True)[:limit]]
+
+    def resources(self, kind: str) -> list[str]:
+        names: dict[str, None] = {}
+        for root in reference_search_roots(kind, self.workspace, self.output_root):
+            if not root.is_dir():
+                continue
+            try:
+                for path in root.rglob("*"):
+                    if path.is_file() and not any(p.startswith(".") for p in path.relative_to(root).parts):
+                        names[path.stem] = None
+                    if len(names) >= 200:
+                        break
+            except OSError:
+                continue
+        return list(names)
+
+    # ── search ───────────────────────────────────────────────────────────────
+    def search(self, query: str, *, kind: str | None = None, limit: int = 30) -> list[Mention]:
+        """Matches for `query`, best first; only `kind` when one is given."""
+        found: list[Mention] = []
+
+        def add(k: str, values: Iterable[str], matcher) -> None:
+            if kind and k != kind:
+                return
+            for value in values:
+                hit = matcher(query, value)
+                if hit is not None:
+                    found.append(Mention(k, value, hit[0], hit[1]))
+
+        add("file", self.files(), _match_path)
+        add("folder", self.folders(), _match_path)
+        # Tickers by exact, prefix or substring only: "fx" scattered through
+        # NFLX is not a way anyone looks for Netflix.
+        add("asset", self.symbols, lambda q, v: (h if (h := _match(q, v)) and h[0] < 40 else None))
+        if query and _looks_like_symbol(query) and query.upper() not in self.symbols and kind in (None, "asset"):
+            found.append(Mention("asset", query.upper(), 30, tuple(range(len(query)))))
+        for resource in RESOURCE_KINDS:
+            add(resource, self.resources(resource), _match)
+        asset_rank = 0 if _looks_like_symbol(query) else 8
+        found.sort(key=lambda m: (m.score, asset_rank if m.kind == "asset" else _KIND_ORDER.get(m.kind, 9),
+                                  len(m.value), m.value))
+        # Letters scattered through a long path ("AAP" in providers/llm/ollama.py)
+        # are noise once there is a popup's worth of closer matches.
+        if sum(1 for m in found if m.score < 40) >= 8:
+            found = [m for m in found if m.score < 40]
+        return found[:limit]
+
+
+def _looks_like_symbol(text: str) -> bool:
+    """A ticker someone is typing: "AAPL", "0700.HK", "BTC-USD" — not "fx" or "readme"."""
+    raw = text.strip()
+    return 1 <= len(raw) <= 12 and raw.upper() == raw and any(ch.isalnum() for ch in raw) and " " not in raw
+
+
+__all__ = ["Mention", "MentionIndex"]

aria_code/ui/picker.py

@@ -0,0 +1,248 @@
+"""Arrow-key selector and async wrapper used by model/skill picker dialogs.
+
+    from ui.picker import arrow_select, run_picker_in_thread
+"""
+
+from __future__ import annotations
+
+import asyncio
+import os
+import sys
+
+from aria_code.ui.console import _HAS_TERMIOS, _esc_watcher
+
+if _HAS_TERMIOS:
+    import termios
+    import tty
+    import select as _select
+
+
+def arrow_select(options: list, selected: int = 0, title: str = "",
+                 max_visible: int = 10,
+                 controls_hint: str = "↑↓  Enter  Esc/q Cancel",
+                 collapse_to: str | None = None,
+                 shortcuts: dict | None = None,
+                 numbered: bool = False) -> int:
+    """Interactive arrow-key selector with scrolling.
+
+    Args:
+        options:     list of ``(label, description)`` tuples or plain strings
+        selected:    initially highlighted index
+        title:       optional header line
+        max_visible: max rows shown at once; scrolls when list is larger
+        collapse_to: when given, the menu is erased once answered and one
+                     line is left in its place — "✓ Yes  fx.py" — instead of
+                     the whole menu, as Codex leaves an answered approval.
+                     The text names what was being approved.
+        shortcuts:   ``{"y": 0, "n": 3}`` — one key answers with that option
+                     at once; the key is shown after its label, "(y)".
+        numbered:    show "1." … before labels; digits 1–9 answer directly.
+    Returns:
+        index of chosen option, or -1 if cancelled
+    """
+    if not options:
+        return -1
+    keys = {str(key): index for key, index in (shortcuts or {}).items()
+            if len(str(key)) == 1 and 0 <= index < len(options)}
+    key_of = {index: key for key, index in keys.items()}
+
+    def _label(index: int, label: str) -> str:
+        text = f"{index + 1}. {label}" if numbered else label
+        return f"{text} ({key_of[index]})" if index in key_of else text
+
+    if not _HAS_TERMIOS or not sys.stdin.isatty():
+        if title:
+            print(f"\n  {title}\n")
+        for i, opt in enumerate(options):
+            label = opt[0] if isinstance(opt, tuple) else opt
+            marker = "❯" if i == selected else " "
+            print(f"  {marker} {i + 1:2d}. {_label(i, label) if keys else label}")
+        try:
+            c = input("\n  Enter number (or Enter to keep current): ").strip()
+            if not c:
+                return selected
+            if c in keys:
+                return keys[c]
+            idx = int(c) - 1
+            return idx if 0 <= idx < len(options) else -1
+        except (ValueError, EOFError, KeyboardInterrupt):
+            return -1
+
+    n       = len(options)
+    visible = min(max_visible, n)
+    scroll  = max(0, selected - visible + 1)
+
+    fd = sys.stdin.fileno()
+    old_settings = termios.tcgetattr(fd)
+
+    try:
+        _tcols = os.get_terminal_size(fd).columns
+    except Exception:
+        _tcols = 80
+
+    _rule = "─" * min(_tcols, 72)
+
+    def _display_width(s: str) -> int:
+        import re as _re
+        clean = _re.sub(r'\x1b\[[0-9;]*[mJKHABCDfGrs]', '', s)
+        w = 0
+        for ch in clean:
+            cp = ord(ch)
+            if (0x1100 <= cp <= 0x115F or 0x2E80 <= cp <= 0xA4CF or
+                    0xAC00 <= cp <= 0xD7AF or 0xF900 <= cp <= 0xFAFF or
+                    0xFE10 <= cp <= 0xFE1F or 0xFE30 <= cp <= 0xFE4F or
+                    0xFF01 <= cp <= 0xFF60 or 0xFFE0 <= cp <= 0xFFE6 or
+                    0x3000 <= cp <= 0x303F):
+                w += 2
+            else:
+                w += 1
+        return w
+
+    def _physical_lines(text: str) -> int:
+        dw = _display_width(text)
+        return max(1, (dw + _tcols - 1) // _tcols)
+
+    def _raw(s: str):
+        os.write(1, s.encode())
+
+    def _render():
+        nonlocal scroll
+        if selected < scroll:
+            scroll = selected
+        elif selected >= scroll + visible:
+            scroll = selected - visible + 1
+
+        buf = ""
+        if _render.drawn:
+            buf += f"\033[{_render.last_phys_height}A"
+
+        phys_height = 0
+        for row in range(visible):
+            idx   = scroll + row
+            opt   = options[idx]
+            label = opt[0] if isinstance(opt, tuple) else opt
+            desc  = opt[1] if isinstance(opt, tuple) and len(opt) > 1 else ""
+            if not label.strip().startswith("──"):
+                label = _label(idx, label)
+            if label.strip().startswith("──"):
+                line = f"  \033[2m{label}\033[0m"
+            elif idx == selected:
+                _accent = os.getenv("ARIA_ACCENT_COLOR", "192;128;80")
+                line = f"  \033[1m\033[38;2;{_accent}m❯\033[0m \033[1m{label}\033[0m"
+                if desc:
+                    line += f"  \033[2m{desc}\033[0m"
+            else:
+                line = f"    {label}"
+                if desc:
+                    line += f"  \033[2m{desc}\033[0m"
+            buf += f"\033[2K{line}\n"
+            phys_height += _physical_lines(line)
+
+        if n > visible:
+            hint = f"  \033[2m{selected + 1}/{n}\033[0m"
+            buf += f"\033[2K{hint}\n"
+        else:
+            buf += "\033[2K\n"
+        phys_height += 1
+
+        _render.last_phys_height = phys_height
+        _raw(buf)
+        _render.drawn = True
+
+    _render.drawn = False
+    _render.last_phys_height = visible + 1
+    header_text = f"  {title}  {controls_hint}" if title else f"  {controls_hint}"
+    # blank line + rule, then the title/hint line(s) + blank line
+    header_height = 2 + _physical_lines(header_text) + 1
+    result = -1
+
+    def _choose() -> int:
+        nonlocal selected
+        while True:
+            ch = os.read(fd, 1)
+            if ch == b'\x1b':
+                seq = b''
+                if _select.select([fd], [], [], 0.05)[0]:
+                    seq = os.read(fd, 2)
+                if seq == b'[A':
+                    selected = (selected - 1) % n; _render()
+                elif seq == b'[B':
+                    selected = (selected + 1) % n; _render()
+                elif seq == b'[5~':
+                    selected = max(0, selected - visible); _render()
+                elif seq == b'[6~':
+                    selected = min(n - 1, selected + visible); _render()
+                elif not seq:
+                    return -1
+            elif ch in (b'\r', b'\n'):
+                return selected
+            elif ch.decode(errors="ignore") in keys:
+                selected = keys[ch.decode(errors="ignore")]
+                return selected
+            elif numbered and ch.isdigit() and 1 <= int(ch) <= n:
+                selected = int(ch) - 1
+                return selected
+            elif ch == b'q':
+                return -1
+            elif ch == b'k':
+                selected = (selected - 1) % n; _render()
+            elif ch == b'j':
+                selected = (selected + 1) % n; _render()
+            elif ch == b'g':
+                selected = 0; _render()
+            elif ch == b'G':
+                selected = n - 1; _render()
+            elif ch in (b'\x03', b'\x04'):
+                return -1
+
+    try:
+        _esc_watcher.pause()
+        tty.setcbreak(fd)
+        sys.stdout.flush()
+
+        # Top boundary
+        _raw(f"\n  \033[2m{_rule}\033[0m\n")
+        if title:
+            _raw(f"  \033[1m{title}\033[0m  \033[2m{controls_hint}\033[0m\n\n")
+        else:
+            _raw(f"  \033[2m{controls_hint}\033[0m\n\n")
+
+        _render()
+        result = _choose()
+        return result
+    except (EOFError, KeyboardInterrupt, OSError):
+        return -1
+    finally:
+        termios.tcsetattr(fd, termios.TCSADRAIN, old_settings)
+        _esc_watcher.resume()
+        if collapse_to is not None and _render.drawn:
+            label = ""
+            if 0 <= result < n:
+                opt = options[result]
+                label = opt[0] if isinstance(opt, tuple) else opt
+            declined = result < 0 or label.strip().lower().startswith(("no", "否", "拒绝", "取消", "cancel"))
+            mark = "\033[31m✗\033[0m" if declined else "\033[32m✓\033[0m"
+            shown = label or "Cancelled"
+            subject = f"  \033[2m{collapse_to}\033[0m" if collapse_to else ""
+            # Up over the header and the menu, clear to the end, one line instead.
+            _raw(f"\033[{header_height + _render.last_phys_height}A\r\033[J  {mark} {shown}{subject}\n")
+        else:
+            _raw(f"  \033[2m{_rule}\033[0m\n\n")
+
+
+async def run_picker_in_thread(options: list, current_idx: int,
+                               title: str, max_visible: int = 14,
+                               controls_hint: str = "↑↓  Enter  Esc/q Cancel") -> int:
+    """Run arrow_select in an executor thread to avoid kqueue conflicts on macOS."""
+    loop = asyncio.get_running_loop()
+    return await loop.run_in_executor(
+        None,
+        lambda: arrow_select(
+            options, current_idx, title, max_visible, controls_hint
+        ),
+    )
+
+
+# Back-compat aliases used by aria_cli.py
+_arrow_select = arrow_select
+_run_picker_in_thread = run_picker_in_thread

aria_code/ui/render/__init__.py

@@ -0,0 +1,11 @@
+"""UI rendering helpers — team, finance, market output formatters."""
+
+from .team import render_verdict_banner, render_team_table
+from .finance import render_macro_result, render_cb_rates, render_econ_calendar
+from .market import print_quote_result, print_ta_result
+
+__all__ = [
+    "render_verdict_banner", "render_team_table",
+    "render_macro_result", "render_cb_rates", "render_econ_calendar",
+    "print_quote_result", "print_ta_result",
+]