aria-code 0.167.0__py3-none-win_amd64.whl

aria_code/apps/cli/web_login.py

@@ -0,0 +1,136 @@
+"""Sign in through the account page, the way Claude Code and Codex do.
+
+``/login`` opens a page on Arthera's own auth host. The user chooses how to sign
+in there (Google, Apple or email, and email can be a new account) and the page
+hands the session back to this process on a loopback port. Nothing is typed in
+the terminal and no provider is chosen for the user.
+
+The hand-back is bound to this process, not merely to "whoever is listening":
+
+* ``state`` is random and checked on the way back, so a callback this run did
+  not start is ignored;
+* a PKCE ``code_verifier`` stays here; only its SHA-256 goes into the page. The
+  one-time code in the redirect is useless without it, so a program that sees
+  the redirect cannot redeem it;
+* the credential never appears in a URL. The redirect carries a short code and
+  the session is fetched over POST.
+
+Page: the /cli-login route of apps/web. Server side: apps/api/src/routes/auth_v2_routes.py
+(/cli/handoff, /cli/exchange).
+"""
+
+from __future__ import annotations
+
+import base64
+import hashlib
+import http.server
+import os
+import secrets
+import threading
+import urllib.parse
+import webbrowser
+from typing import Any, Dict
+
+from .google_login import _CallbackResult, _free_port, _post_json
+
+# The apex is Firebase Hosting and the Firebase auth domain, so the page and the
+# sign-in popup are same-origin there.
+from aria_code.service_endpoints import SITE_URL, current_url
+AUTH_ORIGIN = SITE_URL
+LOGIN_PATH = "/cli-login"
+_TIMEOUT_SECONDS = 300
+
+
+def auth_origin() -> str:
+    """The host that serves the sign-in page. ARIA_AUTH_URL overrides it for staging."""
+    return current_url(os.getenv("ARIA_AUTH_URL", "").strip() or AUTH_ORIGIN, website=True)
+
+
+def pkce_pair() -> tuple[str, str]:
+    """A code verifier and its S256 challenge (RFC 7636)."""
+    verifier = secrets.token_urlsafe(48)  # 64 characters, inside the 43-128 the spec allows
+    digest = hashlib.sha256(verifier.encode("ascii")).digest()
+    return verifier, base64.urlsafe_b64encode(digest).rstrip(b"=").decode("ascii")
+
+
+def _handler(result: _CallbackResult, state: str):
+    class Handler(http.server.BaseHTTPRequestHandler):
+        def do_GET(self):  # noqa: N802 - name fixed by BaseHTTPRequestHandler
+            parsed = urllib.parse.urlparse(self.path)
+            params = {k: v[0] for k, v in urllib.parse.parse_qs(parsed.query).items()}
+            if parsed.path != "/callback" or not secrets.compare_digest(params.get("state", ""), state):
+                # Not this run's callback: ignore it and keep waiting for ours.
+                self.send_response(404)
+                self.end_headers()
+                return
+            ok = "handoff_code" in params
+            body = (
+                "<html><body style='font-family:system-ui;padding:3rem'>"
+                f"<h2>{'Signed in.' if ok else 'Sign-in failed.'}</h2>"
+                "<p>You can close this tab and return to the terminal.</p>"
+                "</body></html>"
+            ).encode("utf-8")
+            self.send_response(200 if ok else 400)
+            self.send_header("Content-Type", "text/html; charset=utf-8")
+            self.send_header("Content-Length", str(len(body)))
+            self.send_header("Referrer-Policy", "no-referrer")
+            self.send_header("Cache-Control", "no-store")
+            self.end_headers()
+            self.wfile.write(body)
+            result.params = params
+            result.received.set()
+
+        def log_message(self, *args):  # keep the terminal clean
+            return
+
+    return Handler
+
+
+def run_web_login(api_url: str, *, open_browser=webbrowser.open, timeout: int = _TIMEOUT_SECONDS) -> Dict[str, Any]:
+    """Drive the whole flow; return the stored-credential fields.
+
+    Raises RuntimeError with a message suitable for display on any failure.
+    """
+    api_url = api_url.rstrip("/")
+    port = _free_port()
+    state = secrets.token_urlsafe(24)
+    verifier, challenge = pkce_pair()
+    result = _CallbackResult()
+    server = http.server.HTTPServer(("127.0.0.1", port), _handler(result, state))
+    thread = threading.Thread(target=server.serve_forever, daemon=True)
+    thread.start()
+    try:
+        url = f"{auth_origin()}{LOGIN_PATH}?" + urllib.parse.urlencode(
+            {"port": port, "state": state, "code_challenge": challenge, "code_challenge_method": "S256"}
+        )
+        if not open_browser(url):
+            raise RuntimeError("Could not open a browser. Visit this URL manually:\n  " + url)
+        if not result.received.wait(timeout=timeout):
+            raise RuntimeError(f"Timed out after {timeout}s waiting for the browser.")
+    finally:
+        server.shutdown()
+        server.server_close()
+
+    code = result.params.get("handoff_code")
+    if not code:
+        raise RuntimeError(result.params.get("message") or "The sign-in did not carry a handoff code.")
+    try:
+        reply = _post_json(f"{api_url}/api/v2/auth/cli/exchange",
+                           {"code": code, "code_verifier": verifier, "state": state})
+    except Exception as exc:
+        raise RuntimeError(f"Could not redeem the sign-in: {exc}") from exc
+    data = reply.get("data") or {}
+    if not data.get("auth_token"):
+        raise RuntimeError("The sign-in did not return a session.")
+    return {
+        "auth_token": data["auth_token"],
+        "refresh_token": data.get("refresh_token"),
+        "expires_in": str(data["expires_in"]) if data.get("expires_in") is not None else None,
+        "user_id": data.get("user_id"),
+        "email": data.get("email"),
+        "display_name": data.get("display_name"),
+        "provider": "firebase",
+    }
+
+
+__all__ = ["run_web_login", "pkce_pair", "auth_origin", "AUTH_ORIGIN"]

aria_code/apps/cli/workflow_runner.py

@@ -0,0 +1,127 @@
+"""Run a ``.aria/workflows`` file in the REPL, one step at a time.
+
+Each kind of step goes through what already exists for it, so a workflow has
+no powers of its own: ``run`` through the ``run_command`` tool (command
+policy, sandbox, output display), ``prompt`` through ``send_message`` (tools,
+approvals, checks, task worktree, transaction point), ``command`` through
+the slash-command dispatcher.
+
+A step fails when its command exits non-zero, when its turn leaves the code
+failing checks it did not fail before (or gets no answer), or when its slash
+command does not exist. The first failure stops the workflow unless the step
+says ``continue_on_error``; declining a ``confirm`` step stops it too.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import sys
+import time
+from dataclasses import dataclass
+from typing import Any, Callable
+
+from aria_code.runtime.workflows import Workflow, WorkflowStep, variables
+
+PASSED, FAILED, SKIPPED, DECLINED = "passed", "failed", "skipped", "declined"
+_MARKS = {PASSED: "✓", FAILED: "✗", SKIPPED: "–", DECLINED: "–"}
+
+
+@dataclass
+class StepResult:
+    name: str
+    status: str
+    detail: str = ""
+    seconds: float = 0.0
+
+
+def _namespace(terminal: Any) -> dict:
+    return vars(sys.modules[type(terminal).__module__])
+
+
+async def _run_command_step(terminal: Any, step: WorkflowStep, text: str) -> tuple[bool, str]:
+    from aria_code.apps.cli.providers.runtime_bridge import build_tool_executor
+    from aria_code.runtime.approval import ApprovalDecision
+
+    config = terminal.config
+    executor = build_tool_executor(
+        _namespace(terminal)["LOCAL_TOOLS"], config,
+        lambda: {"_session_id": getattr(terminal, "session_id", "")},
+    )
+    root = config.get("_session_workspace_root") or None
+    params = {"command": text, "timeout": step.timeout, **({"cwd": root} if root else {})}
+    # The user ran the workflow, and trusted its file before the first run;
+    # the command policy and sandbox still apply, as they do to /verify.
+    approval = ApprovalDecision.allow(policy="balanced", user_approved=True)
+    result = await asyncio.to_thread(executor.execute_local, "run_command", params, approval=approval)
+    if not result.get("success"):
+        return False, str(result.get("error") or "command failed")
+    code = (result.get("data") or {}).get("exit_code", 0)
+    return code == 0, f"exit {code}"
+
+
+async def _prompt_step(terminal: Any, text: str) -> tuple[bool, str]:
+    before = str(getattr(terminal, "_code_verdict", "") or "")
+    length = len(terminal.conversation)
+    await terminal.send_message(text)
+    answered = len(terminal.conversation) > length and terminal.conversation[-1].get("role") == "assistant"
+    after = str(getattr(terminal, "_code_verdict", "") or "")
+    if not answered:
+        return False, "no answer"
+    if after == "failed" and before != "failed":
+        return False, "checks failed after this step"
+    return True, f"checks {after}" if after else "answered"
+
+
+async def _slash_step(terminal: Any, workflow: Workflow, text: str) -> tuple[bool, str]:
+    name = text.split(maxsplit=1)[0].lower()
+    if name.lstrip("/") == workflow.name:
+        return False, "a workflow cannot run itself"
+    commands = terminal.commands
+    if not commands.is_command(text):
+        return False, f"unknown command {name}"
+    await commands.execute(text)
+    return True, name
+
+
+async def run_workflow(terminal: Any, workflow: Workflow, args: str = "", *,
+                       ask: Callable[[str], bool], say: Callable[[str, str], None]) -> list[StepResult]:
+    values = variables(workflow, args)
+    results: list[StepResult] = []
+    total = len(workflow.steps)
+    stopped = False
+    for index, step in enumerate(workflow.steps, 1):
+        if stopped:
+            results.append(StepResult(step.name, SKIPPED))
+            continue
+        text = step.render(values)
+        say(f"[{index}/{total}] {step.name}", "bold")
+        if step.confirm and not ask(f"  Run “{step.name}”: {text[:80]}? [y/N] "):
+            results.append(StepResult(step.name, DECLINED, "declined"))
+            stopped = True
+            continue
+        started = time.time()
+        try:
+            if step.kind == "run":
+                ok, detail = await _run_command_step(terminal, step, text)
+            elif step.kind == "prompt":
+                ok, detail = await _prompt_step(terminal, text)
+            else:
+                ok, detail = await _slash_step(terminal, workflow, text)
+        except Exception as exc:
+            ok, detail = False, f"{type(exc).__name__}: {exc}"
+        results.append(StepResult(step.name, PASSED if ok else FAILED, detail, time.time() - started))
+        if not ok and not step.continue_on_error:
+            stopped = True
+    return results
+
+
+def summary_lines(workflow: Workflow, results: list[StepResult]) -> list[str]:
+    failed = [r for r in results if r.status == FAILED]
+    declined = any(r.status == DECLINED for r in results)
+    verdict = "FAILED" if failed else "STOPPED" if declined else "DONE"
+    lines = [f"/{workflow.name} {verdict}"]
+    for result in results:
+        timing = f" · {result.seconds:.1f}s" if result.seconds >= 0.05 else ""
+        detail = f"  {result.detail}" if result.detail else ""
+        lines.append(f"  {_MARKS[result.status]} {result.name}{detail}{timing}")
+    return lines

aria_code/apps/cli/workspace_route.py

@@ -0,0 +1,121 @@
+"""A task about this folder, sent to a model that cannot touch it.
+
+With backend_chat on, turns go to the Arthera backend, which receives the
+prompt and history but none of Aria's local tools. Asked to run
+`python3 -c 'import calc; print(calc.add(2,3))'` in a folder, it said it had
+no filesystem access and gave the output as 5; the function subtracts, so it
+is -1. The turn reported success with no tools used, and `-p` exited 0. A
+small local model without tool calling is in the same position.
+
+``needs_workspace`` asks only whether a message needs this machine: it names
+a file or imports a module that exists here, uses an @file reference, asks
+for a command to be run, or says "this project", "the failing tests" and the
+like. A question about code in general ("explain Python decorators") does not
+need the folder and is left alone.
+"""
+
+from __future__ import annotations
+
+import re
+from pathlib import Path
+
+_PATH_TOKEN = re.compile(r"[\w./-]+\.[A-Za-z0-9]{1,6}\b|[\w-]+/[\w./-]+")
+_HERE_EN = re.compile(
+    r"\b(?:this|my|our|current)\s+(?:project|repo|repository|folder|directory|codebase|workspace|"
+    r"working\s+tree)\b|\bin\s+here\b|\b(?:the\s+)?failing\s+tests?\b|\bmy\s+(?:code|tests)\b",
+    re.I,
+)
+# Asking for a command to be run needs a tool to run it, wherever it points.
+_RUN_EN = re.compile(r"\b(?:run|execute)\s+(?:`|python3?\b|pytest\b|npm\b|npx\b|node\b|make\b|cargo\b|"
+                     r"go\s+(?:test|run|build)\b|bash\b|sh\b|pip3?\b|uv\b|git\b|ls\b|the\s+tests?\b)", re.I)
+_RUN_ZH = re.compile(r"(?:运行|执行|跑一下|跑)\s*(?:`|python|pytest|npm|node|git|make|命令|脚本|测试)", re.I)
+_IMPORT = re.compile(r"\b(?:import|from)\s+([A-Za-z_]\w*)")
+_HERE_ZH = ("这个项目", "该项目", "当前项目", "这个仓库", "当前仓库", "这个目录", "当前目录", "这个文件夹",
+            "当前文件夹", "这个代码库", "本项目", "本仓库", "失败的测试", "我的代码",
+            "我的项目", "本地项目", "本地文件", "电脑文件", "桌面文件", "创建项目", "新建项目")
+
+
+def needs_workspace(text: str, cwd: Path | str | None = None) -> bool:
+    """True when the message is about files in ``cwd`` (default: the current directory)."""
+    message = str(text or "")
+    if "@file:" in message or "@folder:" in message:
+        return True
+    if _HERE_EN.search(message) or any(word in message for word in _HERE_ZH):
+        return True
+    if re.search(r"\b(?:create|build|scaffold|initialize)\s+(?:a\s+|an\s+|new\s+)?(?:react\s+|next\.js\s+)?(?:app|project|website)\b", message, re.I):
+        return True
+    if _RUN_EN.search(message) or _RUN_ZH.search(message):
+        return True
+    base = Path(cwd or Path.cwd())
+    for module in _IMPORT.findall(message):
+        if (base / f"{module}.py").is_file() or (base / module / "__init__.py").is_file():
+            return True
+    tokens = _PATH_TOKEN.findall(message)
+    # Chinese prose can touch an ASCII filename without whitespace (修改calc.py).
+    tokens += re.findall(r"[A-Za-z0-9_./~-]+\.[A-Za-z0-9]{1,6}\b", message)
+    for token in tokens:
+        candidate = token.strip("./") if token.startswith("./") else token
+        try:
+            if candidate and (base / candidate).exists():
+                return True
+        except (OSError, ValueError):
+            continue
+    return False
+
+
+def route_has_tools(model: str, config: dict, api_url: str | None) -> bool:
+    """Whether this turn's model can call Aria's local tools."""
+    try:
+        from aria_code.model_capability import get_model_capability
+
+        capability = get_model_capability(model)
+        if not (capability.tool_calls and capability.context_window >= 8192):
+            return False
+    except Exception:
+        pass
+    try:
+        from aria_code.apps.cli.providers.chat_routing import model_receives_local_tools
+
+        return model_receives_local_tools(model, config, api_url)
+    except Exception:
+        return True
+
+
+def no_tools_message(config: dict, *, lang: str = "en") -> str:
+    """Why the model cannot do this here, and what to change."""
+    backend = bool(config.get("backend_chat"))
+    if lang == "zh":
+        why = ("当前通过 Arthera 云端对话（backend_chat），那里的模型读不到这个文件夹，也不能运行命令"
+               if backend else "当前模型不支持工具调用，读不到这个文件夹，也不能运行命令")
+        return (f"{why}，关于这里文件的回答只能是推测。要在这个文件夹里写代码、跑测试，请用 /model "
+                "选一个能调用工具的模型（例如 Vertex 上的 Gemini、OpenAI 或 Ollama 的 qwen2.5-coder），"
+                "或用 aria-code --local。")
+    why = ("Turns go to Arthera cloud chat (backend_chat), where the model cannot read this folder or run "
+           "commands" if backend else "The current model cannot call tools, so it cannot read this folder "
+           "or run commands")
+    return (f"{why}; anything it says about files here is a guess. To work on code in this folder, pick a "
+            "model that runs tools with /model (Gemini on Vertex, OpenAI, or an Ollama model such as "
+            "qwen2.5-coder), or start with aria-code --local.")
+
+
+def workspace_config(text: str, model: str, config: dict, api_url: str | None) -> dict:
+    """Choose authenticated Google inference with local tools for workspace tasks.
+
+    Change only this turn's inference transport, never the saved config or
+    the user's model. A backend chat setting must not turn edits into guesses.
+    """
+    from aria_code.apps.cli.providers.chat_routing import force_backend, model_provider, normalize_provider_name
+    if not needs_workspace(text) or not force_backend(config, api_url):
+        return config
+    if config.get("backend_local_tools"):
+        return config
+    provider = model_provider(model) or normalize_provider_name(config.get("local_provider", ""))
+    if provider not in {"google", "vertexai", "vertex-ai", "google-genai"}:
+        return config
+    from aria_code.apps.cli.providers.base import google_readiness
+    if google_readiness(config):
+        return config
+    return {**config, "backend_chat": False, "_workspace_transport": "google"}
+
+
+__all__ = ["needs_workspace", "route_has_tools", "no_tools_message", "workspace_config"]

aria_code/apps/daemon/README.md

@@ -0,0 +1,14 @@
+# Daemon App
+
+Target role: local-first gateway process for background jobs and external
+clients.
+
+Responsibilities:
+
+- manage long-running sessions and task queues;
+- expose local MCP or HTTP control surfaces;
+- coordinate channel adapters;
+- keep user data local unless explicit opt-in allows upload.
+
+The daemon should not implement market data, reports, broker logic, or model
+reasoning directly. Those belong behind package services.

aria_code/apps/vscode/README.md

@@ -0,0 +1,115 @@
+# Aria Code — VS Code Extension
+
+AI-powered financial analysis sidebar for VS Code, connected to the Aria Code backend.
+
+## Requirements
+
+- VS Code 1.85 or later
+- Aria Code backend running locally or on a reachable API host
+
+## Start the backend
+
+```bash
+# From the Aria Code project root:
+python3 aria_daemon.py
+
+# Or start the FastAPI server directly:
+uvicorn apps.api.src.main:app --host 0.0.0.0 --port 8000
+```
+
+## Install from VSIX (recommended)
+
+### Step 1 — Build the extension package
+
+```bash
+cd apps/vscode
+npm install --save-dev @vscode/vsce
+npx vsce package
+# Produces: aria-code-1.0.0.vsix
+```
+
+### Step 2 — Install in VS Code
+
+**Option A — command line:**
+```bash
+code --install-extension aria-code-1.0.0.vsix
+```
+
+**Option B — VS Code UI:**
+1. Open VS Code
+2. Go to **Extensions** (⇧⌘X)
+3. Click the **...** menu (top-right of Extensions panel)
+4. Choose **Install from VSIX...**
+5. Select `aria-code-1.0.0.vsix`
+
+## Install for development (no build step)
+
+```bash
+# Copy the extension folder to VS Code extensions directory
+cp -r apps/vscode ~/.vscode/extensions/aria-code-1.0.0
+
+# Then reload VS Code (⇧⌘P → "Developer: Reload Window")
+```
+
+## Features
+
+| Feature | Description |
+|---|---|
+| **Market tab** | Live indices (S&P 500, Nasdaq, 沪深300, BTC), auto-refreshes every 60 s |
+| **Portfolio tab** | Portfolio overview from your connected broker |
+| **Chat tab** | Ask Aria AI anything — markets, stocks, analysis |
+| **Alerts tab** | View and manage price alerts |
+| **Status bar** | Shows `Aria Online / Offline` — polls `/health` every 30 s |
+| **Analyze Selection** | Right-click selected text → "Analyze with Aria AI" |
+
+## Usage
+
+1. After installing, click the **graph icon** in the VS Code Activity Bar (left sidebar)
+2. The **Aria Financial** panel opens with Market, Portfolio, Chat, and Alerts tabs
+3. Make sure the backend is running — the status bar shows connection state
+
+### Analyze code/text with AI
+
+1. Select any text in your editor
+2. Right-click → **Analyze with Aria AI**
+3. Aria switches to the Chat tab and sends your selection for analysis
+
+### Keyboard shortcut (optional)
+
+Add to your `keybindings.json`:
+```json
+{
+  "key": "ctrl+shift+a",
+  "command": "aria-code.openPanel"
+}
+```
+
+## API Endpoints Used
+
+| Endpoint | Purpose |
+|---|---|
+| `GET /health` | Connection health check (every 30 s) |
+| `GET /api/v1/institution/market/indices` | Major market indices |
+| `GET /api/v2/market/quote?symbols=...` | Fallback quote data |
+| `GET /api/v1/institution/analysis/morning-brief` | Morning market brief |
+| `GET /api/v1/institution/portfolio/overview` | Portfolio overview |
+| `POST /api/v2/ai/chat` | AI chat messages |
+| `GET /api/v2/alert/list` | Price alerts list |
+| `POST /api/v2/alert/create` | Create new alert |
+| `DELETE /api/v2/alert/:id` | Delete alert |
+
+## Troubleshooting
+
+**Status bar shows "Aria Offline"**
+- Confirm the backend is running: `curl http://localhost:8000/health`
+- Check for port conflicts: `lsof -i :8000`
+
+**Extension not appearing after install**
+- Reload VS Code: ⇧⌘P → "Developer: Reload Window"
+
+**Chat returns errors**
+- The AI chat endpoint requires the backend to have a valid LLM provider configured
+- Check backend logs for API key or model errors
+
+**Backend is on a different URL**
+- Set the VS Code setting `ariaCode.apiBase` to the backend base URL you want to use.

aria_code/apps/vscode/package.json

@@ -0,0 +1,70 @@
+{
+  "name": "aria-code",
+  "displayName": "Aria Code — AI Financial Terminal",
+  "description": "AI-powered financial analysis in your editor",
+  "version": "1.0.0",
+  "publisher": "Cinsoul",
+  "engines": {
+    "vscode": "^1.85.0"
+  },
+  "categories": ["Other", "Data Science"],
+  "activationEvents": ["onStartupFinished"],
+  "main": "./extension.js",
+  "contributes": {
+    "configuration": {
+      "title": "Aria Code",
+      "properties": {
+        "ariaCode.apiBase": {
+          "type": "string",
+          "default": "http://127.0.0.1:8000",
+          "description": "Aria backend base URL used by the VS Code extension."
+        }
+      }
+    },
+    "commands": [
+      {
+        "command": "aria-code.openPanel",
+        "title": "Open Aria Dashboard",
+        "category": "Aria"
+      },
+      {
+        "command": "aria-code.analyzeSelection",
+        "title": "Analyze with Aria AI",
+        "category": "Aria"
+      }
+    ],
+    "viewsContainers": {
+      "activitybar": [
+        {
+          "id": "aria-sidebar",
+          "title": "Aria",
+          "icon": "$(graph)"
+        }
+      ]
+    },
+    "views": {
+      "aria-sidebar": [
+        {
+          "id": "aria-code.sidebar",
+          "name": "Aria Financial",
+          "type": "webview"
+        }
+      ]
+    },
+    "menus": {
+      "editor/context": [
+        {
+          "command": "aria-code.analyzeSelection",
+          "when": "editorHasSelection",
+          "group": "aria@1"
+        }
+      ]
+    }
+  },
+  "scripts": {
+    "package": "npx @vscode/vsce package"
+  },
+  "devDependencies": {
+    "@vscode/vsce": "^2.24.0"
+  }
+}