aria-code 0.52.0__py3-none-any.whl

aria_code/apps/cli/commands/file_cmds.py

@@ -0,0 +1,312 @@
+"""FileCommandsMixin — Claude Code-style file ops: read/write/edit/ls/search + staged changes.
+
+Method bodies use aria_cli module globals (self.context.console, self.context.has_rich, the _tool_* file
+tools, _display_path, pathlib, _get_Syntax(), _get__SYNTAX_THEME(), _get_GLOBAL_CHANGE_STORE()), which
+are bound at import time by aria_cli._rebind_mixin_globals(FileCommandsMixin).
+Note cmd_read uses `pathlib.Path` (a bound global), not a bare `Path`, so no
+local import is required.
+"""
+
+from __future__ import annotations
+
+
+import json
+import asyncio
+import datetime
+import time
+import shlex
+import sys
+import os
+from typing import Dict, Any, Optional
+
+# display_path lives in ui.render.output; aria_cli only re-exports it under a
+# private alias, so going through aria_cli was a pointless second hop.
+from aria_code.ui.render.output import display_path as _display_path
+def _tool_read_file(*args, **kwargs):
+    from aria_cli import _tool_read_file as fn
+    return fn(*args, **kwargs)
+def _get_GLOBAL_CHANGE_STORE():
+    from aria_cli import GLOBAL_CHANGE_STORE as val
+    return val
+def _get_Syntax():
+    from ._ui import Syntax as val
+    return val
+def _get__SYNTAX_THEME():
+    from aria_cli import _SYNTAX_THEME as val
+    return val
+def _tool_list_files(*args, **kwargs):
+    from aria_cli import _tool_list_files as fn
+    return fn(*args, **kwargs)
+import pathlib
+def _tool_write_file(*args, **kwargs):
+    from aria_cli import _tool_write_file as fn
+    return fn(*args, **kwargs)
+def _tool_search_code(*args, **kwargs):
+    from aria_cli import _tool_search_code as fn
+    return fn(*args, **kwargs)
+
+import json
+import asyncio
+import datetime
+import time
+import shlex
+import sys
+import os
+from typing import Dict, Any, Optional
+
+
+class FileCommandsMixin:
+    """Mixin: file read/write/edit/list/search and staged-change commands."""
+
+    def cmd_read(self, args: str):
+        """Read a file: /read <path> [offset] [limit]"""
+        parts = args.split()
+        if not parts:
+            self.context.console.print("[dim]Usage: /read <file_path> [start_line] [num_lines][/dim]" if self.context.has_rich
+                          else "Usage: /read <path> [offset] [limit]")
+            return
+        params = {"path": parts[0]}
+        if len(parts) > 1:
+            try:
+                params["offset"] = int(parts[1])
+            except ValueError:
+                pass
+        if len(parts) > 2:
+            try:
+                params["limit"] = int(parts[2])
+            except ValueError:
+                pass
+        result = _tool_read_file(params)
+        if result["success"]:
+            content = result["data"]["content"]
+            if self.context.has_rich:
+                # Use _get_Syntax() for code files
+                path = result["data"]["path"]
+                ext = pathlib.Path(path).suffix
+                lang_map = {".py": "python", ".js": "javascript", ".ts": "typescript",
+                            ".tsx": "typescript", ".jsx": "javascript", ".json": "json",
+                            ".yaml": "yaml", ".yml": "yaml", ".md": "markdown",
+                            ".swift": "swift", ".html": "html", ".css": "css",
+                            ".sh": "bash", ".sql": "sql", ".rs": "rust", ".go": "go"}
+                lang = lang_map.get(ext, "text")
+                # Strip line numbers we added, use _get_Syntax()'s own
+                raw = "\n".join(line.split("│ ", 1)[1] if "│ " in line else line
+                                for line in content.split("\n"))
+                self.context.console.print(f"\n[dim]{_display_path(path)} ({result['data']['lines']} lines)[/dim]")
+                self.context.console.print(_get_Syntax()(raw, lang, line_numbers=True, theme=_get__SYNTAX_THEME()))
+            else:
+                print(f"\n{_display_path(result['data']['path'])} ({result['data']['lines']} lines)")
+                print(content)
+        else:
+            self.context.console.print(f"[red]{result['error']}[/red]" if self.context.has_rich else result["error"])
+
+    def cmd_write(self, args: str):
+        """Write a file: /write [--stage] <path> then paste content, end with EOF line."""
+        parts = args.strip().split()
+        stage_only = False
+        if "--stage" in parts:
+            stage_only = True
+            parts = [p for p in parts if p != "--stage"]
+        path = " ".join(parts).strip()
+        if not path:
+            self.context.console.print("[dim]Usage: /write [--stage] <file_path>[/dim]" if self.context.has_rich
+                          else "Usage: /write [--stage] <path>")
+            self.context.console.print("[dim]Then paste content, end with a line containing only 'EOF'[/dim]" if self.context.has_rich
+                          else "Paste content, end with EOF")
+            return
+        if self.context.has_rich:
+            mode = "Staging" if stage_only else "Writing"
+            self.context.console.print(f"[dim]{mode} {_display_path(path)} — paste content, end with 'EOF' on a new line:[/dim]")
+        else:
+            print(f"{'Staging' if stage_only else 'Writing'} {_display_path(path)} — paste content, end with EOF:")
+        lines = []
+        try:
+            while True:
+                line = input()
+                if line.strip() == "EOF":
+                    break
+                lines.append(line)
+        except (EOFError, KeyboardInterrupt):
+            self.context.console.print("[dim]Cancelled[/dim]" if self.context.has_rich else "Cancelled")
+            return
+        content = "\n".join(lines) + "\n"
+        result = _tool_write_file({"path": path, "content": content, "stage_only": stage_only})
+        if not result["success"]:
+            self.context.console.print(f"[red]{result['error']}[/red]" if self.context.has_rich else result["error"])
+        elif stage_only:
+            change_id = result.get("data", {}).get("change_id", "")
+            msg = f"Staged change {change_id}. Review with /changes, apply with /apply-change {change_id}."
+            self.context.console.print(f"[dim]{msg}[/dim]" if self.context.has_rich else msg)
+
+    async def cmd_edit(self, args: str):
+        """Edit a file interactively: /edit <path> — AI edits based on instruction."""
+        parts = args.strip().split(maxsplit=1)
+        if not parts:
+            self.context.console.print("[dim]Usage: /edit <file_path> <instruction>[/dim]" if self.context.has_rich
+                          else "Usage: /edit <path> <instruction>")
+            return
+        path = parts[0]
+        instruction = parts[1] if len(parts) > 1 else None
+
+        # Read the file first
+        read_result = _tool_read_file({"path": path})
+        if not read_result["success"]:
+            self.context.console.print(f"[red]{read_result['error']}[/red]" if self.context.has_rich else read_result["error"])
+            return
+
+        if not instruction:
+            # Show file and ask for instruction
+            if self.context.has_rich:
+                self.context.console.print(f"[dim]{_display_path(read_result['data']['path'])} ({read_result['data']['lines']} lines)[/dim]")
+            try:
+                instruction = (self.context.console.input("[bold]>[/bold] What to change: ") if self.context.has_rich
+                               else input("What to change: ")).strip()
+            except (EOFError, KeyboardInterrupt):
+                return
+            if not instruction:
+                return
+
+        # Send to AI with file context and ask for edit
+        file_content = read_result["data"]["content"]
+        prompt = (
+            f"I need you to edit the file `{path}`.\n\n"
+            f"Current file content:\n```\n{file_content[:8000]}\n```\n\n"
+            f"Instruction: {instruction}\n\n"
+            f"Use the edit_file tool to make the changes. Remember to use the exact old_string from the file."
+        )
+        await self.terminal.send_message(prompt)
+
+    def cmd_ls(self, args: str):
+        """List files: /ls [path] [pattern]"""
+        parts = args.split()
+        path = parts[0] if parts else "."
+        pattern = parts[1] if len(parts) > 1 else "*"
+        result = _tool_list_files({"path": path, "pattern": pattern})
+        if result["success"]:
+            items = result["data"]["items"]
+            if self.context.has_rich:
+                self.context.console.print(f"\n[dim]{_display_path(result['data']['path'], fallback='directory')} ({result['data']['count']} items)[/dim]\n")
+                for item in items:
+                    if item["type"] == "dir":
+                        self.context.console.print(f"  [bold]{item['name']}/[/bold]")
+                    else:
+                        size = item["size"]
+                        size_str = f"{size:,}" if size < 10000 else f"{size/1024:.1f}K"
+                        self.context.console.print(f"  {item['name']}  [dim]{size_str}[/dim]")
+            else:
+                for item in items:
+                    suffix = "/" if item["type"] == "dir" else ""
+                    print(f"  {item['name']}{suffix}")
+        else:
+            self.context.console.print(f"[red]{result['error']}[/red]" if self.context.has_rich else result["error"])
+
+    def cmd_search(self, args: str):
+        """Search code: /search <pattern> [path] [glob]
+
+        If the second word doesn't look like a file path (no / or .), the whole
+        args string is treated as the pattern and CWD is searched.
+        """
+        args = args.strip().strip('"\'')
+        parts = args.split()
+        if not parts:
+            self.context.console.print("[dim]Usage: /search <pattern> [path] [file_glob][/dim]" if self.context.has_rich
+                          else "Usage: /search <pattern> [path] [glob]")
+            return
+
+        # Determine if second token looks like a file path or directory
+        def _looks_like_path(s: str) -> bool:
+            return bool(s) and any(c in s for c in "/\\.")
+
+        _QUOTES = '"\'`'
+        if len(parts) == 1:
+            # Single token: use as pattern, search CWD
+            params = {"pattern": parts[0].strip(_QUOTES)}
+        elif len(parts) >= 2 and _looks_like_path(parts[1]):
+            # Second token is a path
+            params = {"pattern": parts[0].strip(_QUOTES)}
+            params["path"] = parts[1]
+            if len(parts) > 2:
+                params["glob"] = parts[2]
+        else:
+            # Multi-word pattern with no path (e.g. /search def cmd_model)
+            # Find where the path arg starts (if any)
+            path_idx = None
+            for i, p in enumerate(parts[1:], 1):
+                if _looks_like_path(p):
+                    path_idx = i
+                    break
+            if path_idx:
+                params = {"pattern": " ".join(parts[:path_idx]).strip(_QUOTES)}
+                params["path"] = parts[path_idx]
+                if path_idx + 1 < len(parts):
+                    params["glob"] = parts[path_idx + 1]
+            else:
+                # Whole args is the pattern
+                params = {"pattern": args.strip(_QUOTES)}
+        result = _tool_search_code(params)
+        if result["success"]:
+            matches = result["data"]["matches"]
+            if self.context.has_rich:
+                self.context.console.print(f"\n[dim]{result['data']['count']} matches for '{result['data']['pattern']}'[/dim]\n")
+                for m in matches[:30]:
+                    self.context.console.print(f"  [dim]{m['file']}:{m['line']}[/dim]  {m['content'][:100]}")
+            else:
+                print(f"\n{result['data']['count']} matches:")
+                for m in matches[:30]:
+                    print(f"  {m['file']}:{m['line']}  {m['content'][:100]}")
+        else:
+            self.context.console.print(f"[red]{result['error']}[/red]" if self.context.has_rich else result["error"])
+
+    def cmd_changes(self, args: str):
+        """List staged file changes."""
+        include_closed = "--all" in args.split()
+        changes = _get_GLOBAL_CHANGE_STORE().list(include_closed=include_closed)
+        if not changes:
+            msg = "No staged changes."
+            self.context.console.print(f"[dim]{msg}[/dim]" if self.context.has_rich else msg)
+            return
+        if self.context.has_rich:
+            self.context.console.print()
+            for change in changes:
+                added = sum(1 for line in change.diff.splitlines() if line.startswith("+") and not line.startswith("+++"))
+                removed = sum(1 for line in change.diff.splitlines() if line.startswith("-") and not line.startswith("---"))
+                status = "applied" if change.applied else "rejected" if change.rejected else "pending"
+                color = "green" if change.applied else "red" if change.rejected else "yellow"
+                self.context.console.print(f"[{color}]{change.change_id}[/{color}] [bold]{change.path}[/bold] [dim]{status} +{added}/-{removed}[/dim]")
+                preview = "\n".join(change.diff.splitlines()[:18])
+                if preview:
+                    self.context.console.print(_get_Syntax()(preview, "diff", theme=_get__SYNTAX_THEME()))
+            self.context.console.print()
+        else:
+            for change in changes:
+                status = "applied" if change.applied else "rejected" if change.rejected else "pending"
+                print(f"{change.change_id} {status} {change.path}")
+                print("\n".join(change.diff.splitlines()[:18]))
+
+    def cmd_apply_change(self, args: str):
+        """Apply a staged file change."""
+        change_id = args.strip()
+        if not change_id:
+            self.context.console.print("[dim]Usage: /apply-change <change_id>[/dim]" if self.context.has_rich
+                          else "Usage: /apply-change <change_id>")
+            return
+        try:
+            change = _get_GLOBAL_CHANGE_STORE().apply(change_id)
+            msg = f"Applied change {change.change_id}: {change.path}"
+            self.context.console.print(f"[green]{msg}[/green]" if self.context.has_rich else msg)
+        except Exception as exc:
+            self.context.console.print(f"[red]{exc}[/red]" if self.context.has_rich else str(exc))
+
+    def cmd_reject_change(self, args: str):
+        """Reject a staged file change."""
+        change_id = args.strip()
+        if not change_id:
+            self.context.console.print("[dim]Usage: /reject-change <change_id>[/dim]" if self.context.has_rich
+                          else "Usage: /reject-change <change_id>")
+            return
+        try:
+            change = _get_GLOBAL_CHANGE_STORE().reject(change_id)
+            msg = f"Rejected change {change.change_id}: {change.path}"
+            self.context.console.print(f"[dim]{msg}[/dim]" if self.context.has_rich else msg)
+        except Exception as exc:
+            self.context.console.print(f"[red]{exc}[/red]" if self.context.has_rich else str(exc))

aria_code/apps/cli/commands/finance_service_cmds.py

@@ -0,0 +1,60 @@
+"""CLI discovery for supported financial-market services."""
+
+from __future__ import annotations
+
+
+import json
+import asyncio
+import datetime
+import time
+import shlex
+from typing import Dict, Any, Optional
+
+
+import json
+import asyncio
+import datetime
+import time
+import shlex
+import sys
+import os
+from typing import Dict, Any, Optional
+
+
+import json
+import asyncio
+import datetime
+import time
+import shlex
+import sys
+import os
+from typing import Dict, Any, Optional
+
+
+class FinanceServiceCommandsMixin:
+    def cmd_markets(self, args: str):
+        """Show the applicable finance-service contract for a market/query."""
+        from apps.cli.finance_service_catalog import market_service_summary
+
+        summary = market_service_summary(args)
+        selected = summary["selected"]
+        if self.context.has_rich:
+            from rich.table import Table
+
+            self.context.console.print()
+            title = "金融市场服务" if not selected else f"金融市场服务 · {selected}"
+            table = Table(title=title, show_header=True, header_style="bold cyan")
+            table.add_column("市场", style="bold", no_wrap=True)
+            table.add_column("已接入服务")
+            table.add_column("分析框架")
+            for item in summary["markets"]:
+                prediction = item["prediction"]
+                services = " · ".join(item["services"])
+                if prediction:
+                    services += f"\n预测：{prediction}"
+                table.add_row(item["label"], services, " · ".join(item["analysis"]))
+            self.context.console.print(table)
+            self.context.console.print("[dim]说明：实时结论必须先取得可用数据；数据缺失、过期或覆盖不足时将明确降级，不生成伪精确预测。[/dim]")
+        else:
+            for item in summary["markets"]:
+                print(f"{item['label']}: {', '.join(item['services'])}")

aria_code/apps/cli/commands/fx_commodity_cmds.py

@@ -0,0 +1,123 @@
+"""FxCommodityCommandsMixin — /crypto, /forex, /commodity.
+
+Rendering goes through self.context; the market-data client comes from
+apps/cli/_optional.py. The note that used to be here described binding by
+aria_cli._rebind_mixin_globals, which 40f23c8 stopped calling — this module no
+longer reaches into aria_cli at all.
+
+self._run_in_executor / self._run_parallel / self._fetch_and_display_finance
+are still resolved through the SlashCommands MRO at call time, not as module
+globals.
+"""
+
+from __future__ import annotations
+
+
+import json
+import asyncio
+import datetime
+import time
+import shlex
+from typing import Dict, Any, Optional
+
+def _get__HAS_MDC():
+    from .._optional import HAS_MDC as val
+    return val
+def _get_mdc(*args, **kwargs):
+    from .._optional import get_mdc as fn
+    return fn(*args, **kwargs)
+
+import json
+import asyncio
+import datetime
+import time
+import shlex
+import sys
+import os
+from typing import Dict, Any, Optional
+
+
+import json
+import asyncio
+import datetime
+import time
+import shlex
+import sys
+import os
+from typing import Dict, Any, Optional
+
+
+class FxCommodityCommandsMixin:
+    """Mixin: crypto, forex, and commodity quote commands."""
+
+    async def cmd_crypto(self, args: str):
+        """Crypto data: /crypto BTC ETH  ·  /crypto account (read-only balance)"""
+        # ── Read-only account view: /crypto account [exchange] ───────────────
+        if args.strip().lower().split()[:1] == ["account"]:
+            _parts = args.strip().split()
+            _exch = _parts[1].lower() if len(_parts) > 1 else "binance"
+            if not _get__HAS_MDC():
+                self.context.console.print("[yellow]market_data_client 不可用[/yellow]" if self.context.has_rich else "unavailable")
+                return
+            acct = await self._run_in_executor(
+                lambda: _get_mdc().crypto_account(_exch)
+            )
+            if not acct.get("success"):
+                _err = acct.get("error", "")
+                if _err == "no_api_key":
+                    msg = (f"未配置 {_exch.upper()} 只读 API key。\n"
+                           f"  设置环境变量：{_exch.upper()}_API_KEY 和 {_exch.upper()}_SECRET\n"
+                           f"  [dim]建议用「只读」权限的 key — Aria 永不下单[/dim]")
+                else:
+                    msg = f"读取失败：{_err}"
+                self.context.console.print(f"  [yellow]{msg}[/yellow]" if self.context.has_rich else msg)
+                return
+            holdings = acct.get("holdings", [])
+            if self.context.has_rich:
+                self.context.console.print(f"\n  [bold]{_exch.capitalize()} 账户[/bold]  "
+                              f"[dim]只读 · {len(holdings)} 个资产[/dim]")
+                for h in holdings[:15]:
+                    self.context.console.print(f"    {h['asset']:<8} [bold]{h['amount']:,.6g}[/bold]"
+                                  f"  [dim]可用 {h['free']:,.6g}[/dim]")
+            else:
+                print(f"{_exch} account ({len(holdings)} assets):")
+                for h in holdings[:15]:
+                    print(f"  {h['asset']:<8} {h['amount']:.6g}")
+            return
+
+        symbols = args.upper().split() if args else ["BTC"]
+        if self.context.has_rich:
+            self.context.console.print()
+        for sym in symbols:
+            # yfinance crypto symbol: BTC → BTC-USD, ETH → ETH-USD
+            yf_sym = sym + "-USD" if not sym.endswith("-USD") and "/" not in sym else sym
+            await self._fetch_and_display_finance(
+                "get_crypto_data", {"symbol": sym},
+                label=sym, mdc_fallback_symbol=yf_sym
+            )
+        if self.context.has_rich:
+            self.context.console.print()
+
+    async def cmd_forex(self, args: str):
+        """Forex rates: /forex EUR/USD USD/CNY (with yfinance fallback)"""
+        pairs = args.upper().split() if args else ["EUR/USD"]
+        if self.context.has_rich:
+            self.context.console.print()
+        for pair in pairs:
+            # yfinance forex symbol: EUR/USD → EURUSD=X
+            yf_pair = pair.replace("/", "") + "=X"
+            await self._fetch_and_display_finance(
+                "get_forex_data", {"pair": pair},
+                label=pair, mdc_fallback_symbol=yf_pair
+            )
+        if self.context.has_rich:
+            self.context.console.print()
+
+    async def cmd_commodity(self, args: str):
+        """Commodities: /commodity gold oil silver (parallel fetch)"""
+        items = args.lower().split() if args else ["gold"]
+        await self._run_parallel(
+            "get_commodities_data",
+            [{"commodity": c} for c in items],
+            label_fn=lambda p: f"commodity {p['commodity']}",
+        )