aria-code 0.52.0__py3-none-any.whl

aria_code/apps/cli/config_paths.py

@@ -0,0 +1,73 @@
+"""Shared config path resolution for Aria CLI components."""
+from __future__ import annotations
+
+import os
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Optional
+
+
+@dataclass(frozen=True)
+class AriaConfigPaths:
+    config_dir: Path
+    config_file: Path
+    history_file: Path
+    sessions_dir: Path
+    providers_file: Path
+    hooks_file: Path
+    user_output_root: Path
+    user_generated_dir: Path
+    user_projects_dir: Path
+
+
+def resolve_config_dir() -> Path:
+    """Resolve the user config directory with stable precedence.
+
+    实现已收敛到 packages/aria_core/paths.aria_home()：同一套优先级此前只有
+    配置文件走，另外 38 个文件直接写死 Path.home()/".arthera" 绕过了它，导致
+    新用户的 config 落在 ~/.aria-code 而凭证落在 ~/.arthera。这里保留函数名做
+    兼容，逻辑不再各自维护一份。
+    """
+    from packages.aria_core.paths import aria_home
+
+    return aria_home()
+
+
+def resolve_user_output_root() -> Path:
+    """Resolve the per-user output root for generated code and user artifacts."""
+    configured = os.getenv("ARIA_USER_OUTPUT_ROOT")
+    if configured:
+        return Path(configured).expanduser()
+    return Path.home() / "Documents" / "Aria Code"
+
+
+def resolve_paths(config_dir: Optional[Path] = None) -> AriaConfigPaths:
+    root = Path(config_dir).expanduser() if config_dir else resolve_config_dir()
+    user_output_root = resolve_user_output_root()
+    return AriaConfigPaths(
+        config_dir=root,
+        config_file=root / "config.json",
+        history_file=root / "history",
+        sessions_dir=root / "sessions",
+        providers_file=root / "providers.json",
+        hooks_file=root / "hooks.json",
+        user_output_root=user_output_root,
+        user_generated_dir=user_output_root / "generated",
+        user_projects_dir=user_output_root / "projects",
+    )
+
+
+def config_snapshot(config_dir: Optional[Path] = None) -> dict[str, str]:
+    """Return a JSON-serializable snapshot of resolved config paths."""
+    paths = resolve_paths(config_dir)
+    return {
+        "config_dir": str(paths.config_dir),
+        "config_file": str(paths.config_file),
+        "history_file": str(paths.history_file),
+        "sessions_dir": str(paths.sessions_dir),
+        "providers_file": str(paths.providers_file),
+        "hooks_file": str(paths.hooks_file),
+        "user_output_root": str(paths.user_output_root),
+        "user_generated_dir": str(paths.user_generated_dir),
+        "user_projects_dir": str(paths.user_projects_dir),
+    }

aria_code/apps/cli/config_store.py

@@ -0,0 +1,78 @@
+"""Persistent CLI configuration loading and saving.
+
+CLI adapter for :class:`packages.aria_services.settings.SettingsService` —
+the service owns the merge/normalize/persist mechanics; this module supplies
+the CLI-specific hooks (provider-name normalization, i18n detection, model
+auto-selection) and keeps the historical ``load_cli_config``/``save_cli_config``
+API so existing call sites are untouched.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+
+from aria_code.apps.cli.config_paths import AriaConfigPaths
+from aria_code.packages.aria_services.settings import (  # noqa: F401  (re-exported)
+    STALE_ARIA_MODEL_PREFIXES,
+    SettingsService,
+)
+
+
+def _normalize_provider(name: str) -> str:
+    from apps.cli.providers.chat_routing import normalize_provider_name
+    return normalize_provider_name(name)
+
+
+def _detect_lang() -> str:
+    from apps.cli.i18n import detect_system_lang
+    return detect_system_lang()
+
+
+def build_settings_service(
+    paths: AriaConfigPaths,
+    defaults: dict,
+    *,
+    sync_policy: Callable[[dict], None] | None = None,
+) -> SettingsService:
+    """Construct the SettingsService with the CLI's environment hooks."""
+    return SettingsService(
+        config_dir=paths.config_dir,
+        config_file=paths.config_file,
+        sessions_dir=paths.sessions_dir,
+        defaults=defaults,
+        normalize_provider=_normalize_provider,
+        detect_lang=_detect_lang,
+        on_loaded=sync_policy,
+    )
+
+
+def load_cli_config(
+    paths: AriaConfigPaths,
+    defaults: dict,
+    *,
+    sync_policy: Callable[[dict], None] | None = None,
+) -> dict:
+    """Load config.json, merge with defaults, then apply the project's .ariarc.
+
+    The i18n/chat_routing imports below are bare on purpose: the tests
+    patch those modules, and the packaged root is a different module
+    object, so the packaged form left detect_system_lang unpatched.
+
+    The .ariarc overlay goes last so a repo that pins a model gets it for
+    everyone who opens it, without each developer editing their global config.
+    It is best-effort: a malformed project file must not stop the CLI from
+    starting, because the user would then have no way to run the tool that
+    would fix it.
+    """
+    config = build_settings_service(paths, defaults, sync_policy=sync_policy).load()
+    try:
+        from aria_code.ariarc import apply_to_config
+
+        apply_to_config(config)
+    except Exception:
+        pass
+    return config
+
+
+def save_cli_config(paths: AriaConfigPaths, cfg: dict) -> None:
+    build_settings_service(paths, {}).save(cfg)

aria_code/apps/cli/constants.py

@@ -0,0 +1,88 @@
+from typing import Dict
+
+_PROVIDER_KEY_MAP: Dict[str, str] = {
+    "deepseek":    "DEEPSEEK_API_KEY",
+    "openai":      "OPENAI_API_KEY",
+    "anthropic":   "ANTHROPIC_API_KEY",
+    "claude":      "ANTHROPIC_API_KEY",
+    "groq":        "GROQ_API_KEY",
+    "together":    "TOGETHER_API_KEY",
+    "google":      "GOOGLE_API_KEY",
+    "gemini":      "GOOGLE_API_KEY",
+    "xai":         "XAI_API_KEY",
+    "grok":        "XAI_API_KEY",
+    "mistral":     "MISTRAL_API_KEY",
+    "cohere":      "COHERE_API_KEY",
+    "perplexity":  "PERPLEXITY_API_KEY",
+    "dashscope":   "DASHSCOPE_API_KEY",
+    "aliyun":      "DASHSCOPE_API_KEY",
+    "siliconflow": "SILICONFLOW_API_KEY",
+    "moonshot":    "MOONSHOT_API_KEY",
+    "zhipu":       "ZHIPUAI_API_KEY",
+    "glm":         "ZHIPUAI_API_KEY",
+    "baidu":       "QIANFAN_ACCESS_KEY",
+    "ernie":       "QIANFAN_ACCESS_KEY",
+    "qianfan":     "QIANFAN_ACCESS_KEY",
+    "bytedance":   "ARK_API_KEY",
+    "doubao":      "ARK_API_KEY",
+    "ark":         "ARK_API_KEY",
+    "minimax":     "MINIMAX_API_KEY",
+    "stepfun":     "STEPFUN_API_KEY",
+    "01ai":        "ONEAI_API_KEY",
+    "yi":          "ONEAI_API_KEY",
+}
+
+_DATA_KEY_MAP: Dict[str, str] = {
+    "finnhub":      "FINNHUB_API_KEY",
+    "newsapi":      "NEWS_API_KEY",
+    "brave":        "BRAVE_SEARCH_API_KEY",
+    "tavily":       "TAVILY_API_KEY",
+    "coingecko":    "COINGECKO_API_KEY",
+    "alphavantage": "ALPHA_VANTAGE_API_KEY",
+    "polygon":      "POLYGON_API_KEY",
+    "fmp":          "FMP_API_KEY",
+    "twelvedata":   "TWELVEDATA_API_KEY",
+    "figma":        "FIGMA_API_KEY",
+}
+
+_DATA_SIGNUP_URLS: Dict[str, str] = {
+    "finnhub":      "https://finnhub.io/register",
+    "newsapi":      "https://newsapi.org/register",
+    "brave":        "https://api.search.brave.com/app/keys",
+    "tavily":       "https://app.tavily.com",
+    "coingecko":    "https://www.coingecko.com/en/api",
+    "alphavantage": "https://www.alphavantage.co/support/#api-key",
+    "polygon":      "https://polygon.io/signup",
+    "fmp":          "https://financialmodelingprep.com/register",
+    "twelvedata":   "https://twelvedata.com/register",
+    "figma":        "https://www.figma.com/developers/api#access-tokens",
+}
+
+_LLM_SIGNUP_URLS: Dict[str, str] = {
+    "deepseek":    "https://platform.deepseek.com/api_keys",
+    "openai":      "https://platform.openai.com/api-keys",
+    "anthropic":   "https://console.anthropic.com/settings/keys",
+    "claude":      "https://console.anthropic.com/settings/keys",
+    "groq":        "https://console.groq.com/keys",
+    "together":    "https://api.together.ai/settings/api-keys",
+    "google":      "https://aistudio.google.com/app/apikey",
+    "gemini":      "https://aistudio.google.com/app/apikey",
+    "xai":         "https://console.x.ai",
+    "grok":        "https://console.x.ai",
+    "mistral":     "https://console.mistral.ai/api-keys",
+    "cohere":      "https://dashboard.cohere.com/api-keys",
+    "perplexity":  "https://www.perplexity.ai/settings/api",
+    "dashscope":   "https://dashscope.console.aliyun.com/apiKey",
+    "aliyun":      "https://dashscope.console.aliyun.com/apiKey",
+    "siliconflow": "https://cloud.siliconflow.cn/account/ak",
+    "moonshot":    "https://platform.moonshot.cn/console/api-keys",
+    "zhipu":       "https://open.bigmodel.cn/usercenter/apikeys",
+    "baidu":       "https://qianfan.cloud.baidu.com/user/accessToken",
+    "ernie":       "https://qianfan.cloud.baidu.com/user/accessToken",
+    "bytedance":   "https://ark.volcengine.com/api-key",
+    "doubao":      "https://ark.volcengine.com/api-key",
+    "minimax":     "https://platform.minimaxi.com/user-center/basic-information/interface-key",
+    "stepfun":     "https://platform.stepfun.com/interface-key",
+    "01ai":        "https://platform.lingyiwanwu.com/apikeys",
+    "yi":          "https://platform.lingyiwanwu.com/apikeys",
+}

aria_code/apps/cli/context.py

@@ -0,0 +1,34 @@
+from dataclasses import dataclass, field
+from typing import Any, Dict, Callable
+
+@dataclass
+class AriaContext:
+    """
+    Unified context for Aria CLI commands.
+    This replaces the dynamic `__globals__` injection pattern.
+    Commands should accept this context to access console, workspace, and config.
+    """
+    console: Any = None
+    workspace: Any = None
+    config: Dict[str, Any] = field(default_factory=dict)
+    has_rich: bool = False
+    
+    # Callbacks for config
+    save_config_cb: Callable[[Dict[str, Any]], None] = None
+    load_config_cb: Callable[[], Dict[str, Any]] = None
+    
+    def save_config(self, cfg: dict):
+        if self.save_config_cb:
+            self.save_config_cb(cfg)
+            
+    def load_config(self) -> dict:
+        if self.load_config_cb:
+            return self.load_config_cb()
+        return {}
+    
+    def __post_init__(self):
+        if self.config is None:
+            self.config = {}
+        if self.has_rich is False and self.console is not None:
+            self.has_rich = True
+

aria_code/apps/cli/deterministic.py

@@ -0,0 +1,191 @@
+"""Shared deterministic routing for Aria agent entrypoints.
+
+This module is intentionally UI-free.  The legacy CLI, future daemon/webhook
+entrypoints, and the public SDK can all use the same routing order without
+importing the terminal implementation from ``aria_cli.py``.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Callable
+
+from aria_code.apps.cli.handlers.broker_handlers import handle_broker_query
+from aria_code.apps.cli.handlers.chart_handlers import handle_stock_chart_analysis
+from aria_code.apps.cli.handlers.market_handlers import (
+    _try_handle_market_overview,
+    _try_handle_market_snapshot_analysis,
+)
+from aria_code.apps.cli.handlers.realty_handlers import handle_realty_query
+from aria_code.apps.cli.handlers.strategy_advice import handle_strategy_advice
+from aria_code.apps.cli.utils.market_detect import (
+    _CN_CITIES,
+    _INTL_CITIES,
+    _extract_market_symbol,
+    _is_broker_intent,
+    _is_realty_query,
+    _is_stock_chart_analysis_request,
+)
+
+
+BrokerRegistryFactory = Callable[[], Any]
+
+
+def _pack_handlers(message: str) -> tuple:
+    """Deterministic handlers contributed by the packs this message activates.
+
+    Falls back to the legacy finance handlers if the pack layer is unavailable,
+    so an import problem degrades to the previous behaviour rather than
+    silently dropping domain routing.
+    """
+    try:
+        from aria_code.packs import (
+            activate_packs,
+            active_handlers,
+            load_builtin_packs,
+        )
+
+        load_builtin_packs()
+        return active_handlers(activate_packs(message))
+    except Exception:
+        return (handle_strategy_advice, _handle_stock_chart_analysis)
+
+
+# Names of the handlers that decide for themselves whether a message is theirs
+# and answer without fetching anything. They need no pack activation; see the
+# call site for why.
+#
+# Names rather than function objects, resolved at call time: a module-level
+# tuple of references captures whatever was imported and then ignores anything
+# that replaces the module attribute later, which silently defeats both
+# monkeypatching in tests and any runtime substitution.
+_SELF_GATED_HANDLER_NAMES = ("handle_strategy_advice",)
+
+
+def _self_gated_handlers() -> tuple:
+    return tuple(globals()[name] for name in _SELF_GATED_HANDLER_NAMES)
+
+
+def _missing_broker_registry() -> None:
+    return None
+
+
+@dataclass(frozen=True)
+class DeterministicRouterConfig:
+    """Configuration for deterministic routing outside the model loop."""
+
+    model_has_tools: bool = True
+    has_brokers: bool = False
+    get_broker_registry: BrokerRegistryFactory | None = None
+
+
+def _handle_broker_query(message: str, config: DeterministicRouterConfig) -> dict:
+    return handle_broker_query(
+        message,
+        has_brokers=config.has_brokers,
+        is_broker_intent=_is_broker_intent,
+        get_broker_registry=config.get_broker_registry or _missing_broker_registry,
+    )
+
+
+def _handle_realty_query(message: str) -> dict:
+    return handle_realty_query(
+        message,
+        is_realty_query=_is_realty_query,
+        cn_cities=_CN_CITIES,
+        intl_cities=_INTL_CITIES,
+    )
+
+
+def _handle_stock_chart_analysis(message: str) -> dict:
+    return handle_stock_chart_analysis(
+        message,
+        is_chart_request=_is_stock_chart_analysis_request,
+        extract_symbol=_extract_market_symbol,
+    )
+
+
+def run_deterministic_chain(
+    message: str,
+    *,
+    model_has_tools: bool,
+    history: list | None = None,
+    has_brokers: bool = False,
+    get_broker_registry: BrokerRegistryFactory | None = None,
+) -> dict:
+    """Run the deterministic routing chain used before LLM fallback.
+
+    Order matters:
+    - broker account reads are only used when the model cannot call tools;
+    - realty must run before market parsing, so housing questions do not inherit
+      a ticker;
+    - chart requests run before snapshots;
+    - whole-market overview runs before single-symbol snapshot parsing, so
+      "分析A股" is treated as the A-share market instead of ticker ``A``.
+    """
+
+    config = DeterministicRouterConfig(
+        model_has_tools=model_has_tools,
+        has_brokers=has_brokers,
+        get_broker_registry=get_broker_registry,
+    )
+
+    deterministic: dict = {"success": False}
+    if not config.model_has_tools:
+        deterministic = _handle_broker_query(message, config)
+
+    # Domain handlers run only for packs the message actually activated.  They
+    # used to run against every message: a question about this repository was
+    # walked through the strategy, realty and stock-chart handlers before the
+    # model saw it, which is how a code request came back as a stock quote.
+    # Activation is entity-gated, so a message that names no instrument never
+    # reaches the finance handlers at all.  See aria_code.packs.
+    #
+    # Realty was the last handler still running ungated here, and it moved
+    # behind the same gate in the realty pack: a message must name a city and
+    # a housing term, or name the national market outright. A property-domain
+    # word on its own ("物业", "地产") no longer reaches it, because that word
+    # also appears in the source of every property-management codebase.
+    for handler in _pack_handlers(message):
+        if deterministic.get("success"):
+            break
+        deterministic = handler(message)
+
+    # Self-gated handlers run without a pack activation, because they do not
+    # depend on one.
+    #
+    # The entity gate exists to stop a handler that ANSWERS WITH DATA from
+    # firing when no instrument was named — that is how a question about this
+    # repository came back as a MongoDB stock quote. handle_strategy_advice
+    # answers with static methodology text, names no instrument, and fetches
+    # nothing, so it carries none of that risk. Gating it anyway simply broke
+    # it: "如果我要写一个美股量化策略，你觉得要从几个角度去写" names no ticker,
+    # so no pack activated and the handler was unreachable.
+    #
+    # Its own gate is a three-way conjunction (strategy term AND advice term
+    # AND NOT execution term) that rejects every software-engineering use of
+    # 策略/建议 — "帮我写一个缓存策略", "数据库索引策略有什么建议",
+    # "给我一些代码风格建议" all fall through untouched.
+    for handler in _self_gated_handlers():
+        if deterministic.get("success"):
+            break
+        deterministic = handler(message)
+
+    # Tool-capable models should resolve symbols and fetch market data through
+    # the audited tool loop. The deterministic market handlers can refresh a
+    # large remote symbol universe, which blocks the REPL before the model ever
+    # receives the request. Keep them as the fallback for text-only models.
+    if not deterministic.get("success") and not config.model_has_tools:
+        deterministic = _try_handle_market_overview(message)
+
+    if not deterministic.get("success") and not config.model_has_tools:
+        deterministic = _try_handle_market_snapshot_analysis(message, history=history)
+
+    return deterministic
+
+
+__all__ = [
+    "BrokerRegistryFactory",
+    "DeterministicRouterConfig",
+    "run_deterministic_chain",
+]

aria_code/apps/cli/direct.py

@@ -0,0 +1,48 @@
+"""Direct command dispatcher for non-interactive CLI entrypoints."""
+
+from __future__ import annotations
+
+import inspect
+from typing import Any
+
+from aria_code.apps.cli.commands.catalog import DIRECT_COMMAND_MAP, WATCHABLE_DIRECT_COMMANDS
+
+
+def is_watchable_direct_command(command: str) -> bool:
+    return command.strip().lower() in WATCHABLE_DIRECT_COMMANDS
+
+
+async def dispatch_direct_command(
+    terminal: Any,
+    command: str,
+    command_args: str = "",
+    *,
+    json_output: bool = False,
+    fmt: str = "table",
+    output_file: str | None = None,
+    quiet: bool = False,
+) -> bool:
+    """Dispatch a direct CLI command.
+
+    Returns True when the command was handled by a known direct command handler.
+    Unknown direct commands fall back to the normal prompt path and return False.
+    """
+
+    cmd = command.strip().lower()
+    spec = DIRECT_COMMAND_MAP.get(cmd)
+    if spec is None:
+        await terminal.run_prompt(
+            f"{command} {command_args}".strip(),
+            json_output=json_output,
+            fmt=fmt,
+            output_file=output_file,
+            quiet=quiet,
+        )
+        return False
+
+    handler = getattr(terminal.commands, spec.method_name)
+    result = handler(command_args)
+    if inspect.isawaitable(result):
+        await result
+    return True
+

aria_code/apps/cli/finance_service_catalog.py

@@ -0,0 +1,111 @@
+"""One explicit capability contract for every supported financial market.
+
+This avoids asking an LLM to infer whether an A-share prediction engine, a
+crypto funding-rate feed, or a foreign-exchange quote is applicable.  Routing
+is deterministic and descriptions only advertise data the CLI can actually
+request through its existing tools.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+import re
+
+from aria_code.apps.cli.market_universe import resolve_market_mentions
+
+
+@dataclass(frozen=True)
+class FinanceMarketService:
+    key: str
+    label: str
+    aliases: tuple[str, ...]
+    services: tuple[str, ...]
+    analysis: tuple[str, ...]
+    prediction: str = ""
+
+
+MARKET_SERVICES: tuple[FinanceMarketService, ...] = (
+    FinanceMarketService(
+        "CN", "A 股", ("a股", "沪深", "上证", "深证", "创业板", "科创板"),
+        ("实时行情", "历史K线", "技术指标", "基本面", "公告/新闻", "回测", "组合风控"),
+        ("行情与成交量", "基本面与监管公告", "板块与资金流", "T+1/涨跌停约束回测"),
+        "次交易日预测（覆盖率、数据日期、回测质量必须同时披露）",
+    ),
+    FinanceMarketService(
+        "HK", "港股", ("港股", "恒生", "h股"),
+        ("实时行情", "历史K线", "技术指标", "基本面", "新闻", "组合风控"),
+        ("港币计价与交易时段", "中概/内地政策传导", "公司基本面与行业比较"),
+    ),
+    FinanceMarketService(
+        "US", "美股", ("美股", "纳斯达克", "纽交所", "标普", "道指"),
+        ("实时行情", "历史K线", "技术指标", "财报", "新闻", "回测", "组合风控"),
+        ("财报和指引", "宏观利率与行业估值", "盘前/盘后与公司事件"),
+    ),
+    FinanceMarketService(
+        "GLOBAL", "全球股票与指数", ("欧股", "日股", "全球市场", "指数"),
+        ("实时行情", "历史K线", "技术指标", "新闻", "组合风控"),
+        ("本币与汇率", "本地交易时段", "指数/行业相对表现"),
+    ),
+    FinanceMarketService(
+        "CRYPTO", "加密资产", ("加密", "比特币", "以太坊", "btc", "eth", "币安", "okx"),
+        ("现货行情", "历史K线", "技术指标", "交易所账户只读查询", "资金费率/衍生品（数据源可用时）"),
+        ("24/7市场与流动性", "交易所及对手方风险", "杠杆/资金费率与波动"),
+    ),
+    FinanceMarketService(
+        "FX", "外汇", ("外汇", "汇率", "美元兑", "eur/", "usd/", "jpy"),
+        ("实时汇率", "历史K线", "技术指标", "宏观/新闻"),
+        ("利差与央行政策", "汇率方向和报价惯例", "跨币种风险"),
+    ),
+    FinanceMarketService(
+        "FUTURES", "商品与期货", ("期货", "商品", "黄金", "白银", "原油", "铜", "天然气"),
+        ("连续合约行情", "历史K线", "技术指标", "宏观/新闻"),
+        ("合约月份与展期", "库存/供需/地缘事件", "保证金和杠杆风险"),
+    ),
+)
+
+_BY_KEY = {service.key: service for service in MARKET_SERVICES}
+
+
+def classify_finance_market(text: str) -> FinanceMarketService | None:
+    """Classify a request without network calls; named symbols win over words."""
+    query = str(text or "")
+    mentions = resolve_market_mentions(query, limit=1, load_universe=lambda: [])
+    if mentions:
+        key = mentions[0][1].market
+        if key == "INDEX":
+            symbol = mentions[0][1].symbol.upper()
+            if symbol.endswith((".SS", ".SZ")):
+                key = "CN"
+            elif symbol in {"^HSI", "^HSCE"}:
+                key = "HK"
+            else:
+                key = "GLOBAL"
+        return _BY_KEY.get(key)
+    low = query.lower()
+    for service in MARKET_SERVICES:
+        if any(alias in low for alias in service.aliases):
+            return service
+    if re.search(r"\b\d{6}(?:\.(?:sh|sz|ss))?\b", low):
+        return _BY_KEY["CN"]
+    if re.search(r"\b[A-Z]{1,5}(?:\.[A-Z]{1,4})?\b", query):
+        return _BY_KEY["US"]
+    return None
+
+
+def market_service_summary(text: str = "") -> dict[str, object]:
+    """Return a display-ready and machine-readable market service contract."""
+    selected = classify_finance_market(text)
+    services = (selected,) if selected else MARKET_SERVICES
+    return {
+        "selected": selected.key if selected else None,
+        "markets": [
+            {
+                "key": item.key,
+                "label": item.label,
+                "services": item.services,
+                "analysis": item.analysis,
+                "prediction": item.prediction or None,
+            }
+            for item in services
+        ],
+    }