aria-code 0.167.0__py3-none-win_amd64.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,158 @@
+"""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.
+    """
+    service = build_settings_service(paths, defaults, sync_policy=sync_policy)
+    config = service.load()
+    # The old localhost default is replaced once; see endpoint_migration.
+    from aria_code.apps.cli.endpoint_migration import migrate_config as migrate_endpoint
+
+    moved = migrate_endpoint(config)
+    if moved:
+        try:
+            service.save(config)
+        except Exception:
+            pass
+        _announce_endpoint(moved, config)
+    # A model Google has retired fails on every request. The user's own saved
+    # choice is replaced once and written back; see model_retirement.
+    from aria_code.apps.cli.model_retirement import migrate_config
+
+    saved = migrate_config(config)
+    if saved:
+        try:
+            service.save(config)
+        except Exception:
+            pass
+        _announce(saved, config, pinned=False)
+    try:
+        from aria_code.ariarc import apply_to_config
+
+        apply_to_config(config)
+    except Exception:
+        pass
+    # A project's .ariarc is the user's file: replace in memory, say so, never rewrite it.
+    pinned = migrate_config(config)
+    if pinned:
+        _announce(pinned, config, pinned=True)
+    # Legacy callers read ollama_url. Resolve one effective per-user endpoint
+    # without persisting a process environment override back to the user's file.
+    from aria_code.providers.ollama_models import ollama_base_url
+    try:
+        config["ollama_url"] = ollama_base_url(config)
+    except ValueError:
+        pass  # Selection/inference reports an invalid Ollama address explicitly.
+    return config
+
+
+_ANNOUNCED: set[tuple[str, str]] = set()
+
+
+def _announce_endpoint(changes, config: dict) -> None:
+    """Say once per process that the old localhost default was replaced."""
+    import sys
+
+    zh = str(config.get("ui_lang", "")).lower().startswith("zh")
+    for _key, old, new in changes:
+        if (old, new) in _ANNOUNCED:
+            continue
+        _ANNOUNCED.add((old, new))
+        if zh:
+            msg = (f"ℹ 服务器地址 {old} 是旧版默认值，已改为 {new}。"
+                   "如需使用本机后端，请设置环境变量 ARTHERA_API_URL，或在配置里加 api_url_pinned: true。")
+        else:
+            msg = (f"ℹ The server address {old} was the old default and is now {new}. "
+                   "For a local backend set ARTHERA_API_URL, or add api_url_pinned: true to the config.")
+        try:
+            print(msg, file=sys.stderr)
+        except Exception:
+            pass
+
+
+def _announce(changes, config: dict, *, pinned: bool) -> None:
+    """One line on stderr per retired model, once per process."""
+    import sys
+
+    zh = str(config.get("ui_lang", "")).lower().startswith("zh")
+    for _key, old, new in changes:
+        if (old, new) in _ANNOUNCED:
+            continue
+        _ANNOUNCED.add((old, new))
+        if zh:
+            where = "项目 .ariarc 里固定的" if pinned else "你设置的"
+            tail = "，请修改 .ariarc 里的 model" if pinned else "。可以用 /model 换成其他模型"
+            msg = f"ℹ {where}模型 {old} 已被 Google 停用，本次改用 {new}{tail}。"
+        else:
+            where = "The model pinned in this project's .ariarc" if pinned else "Your model"
+            tail = "; update the model in .ariarc" if pinned else "; use /model to pick another"
+            msg = f"ℹ {where}, {old}, has been retired by Google. Using {new}{tail}."
+        try:
+            print(msg, file=sys.stderr)
+        except Exception:
+            pass
+
+
+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/conversation_policy.py

@@ -0,0 +1,53 @@
+"""Recognize standalone social messages without guessing a task's intent.
+
+Matching the whole message is intentional: ``hi, read README.md`` must keep
+its tools, as must ``yes`` or ``continue`` in an ongoing coding conversation.
+"""
+from __future__ import annotations
+
+import re
+
+_SOCIAL = frozenset({
+    "hi", "hello", "hey", "hiya", "hi there", "hello there", "how are you", "how are you doing", "good morning", "good afternoon", "good evening",
+    "hi aria", "hello aria", "hey aria", "thanks", "thank you", "thanks aria",
+    "bye", "goodbye", "你好", "你好啊", "你好呀", "您好", "嗨", "哈喽", "在吗", "你在吗", "早安", "晚安", "早上好", "下午好", "晚上好", "👋",
+    "你好aria", "aria你好", "你好 aria", "aria 你好", "hiaria", "helloaria", "heyaria", "谢谢", "谢谢你", "再见",
+})
+
+
+def is_social_message(message: str) -> bool:
+    text = re.sub(r"[!！?？。，,.~～]+", "", str(message or "").strip().casefold())
+    text = " ".join(text.split())
+    return text in _SOCIAL
+
+
+def is_capability_question(message: str) -> bool:
+    """Standalone questions about the assistant, not requests to act on a subject.
+
+    Full matching keeps a mixed request such as "what can you do; analyze AAPL"
+    on the normal execution path. Mentioning stocks in a capability question
+    does not ask for a current financial conclusion.
+    """
+    text = " ".join(str(message or "").strip().casefold().split()).rstrip("?？!！。.")
+    chinese = re.sub(r"\s+", "", text)
+    chinese = re.sub(r"^(?:除了|除)[^。！？!?;；]+?[，,]((?:你|您|aria(?:code)?).+)$", r"\1", chinese)
+    if re.fullmatch(
+        r"(?:你|您|aria(?:code)?)(?:(?:除了|除)[^。！？!?;；]+?(?:之外|以外|外)?[，,]?)?"
+        r"还?(?:能|可以|会)(?:帮我|帮助我)?(?:做|干)(?:些|一些|点)?(?:什么|啥)(?:事情|工作|任务)?(?:吗|呢|呀|啊)?",
+        chinese,
+    ):
+        return True
+    if re.fullmatch(r"(?:你|您|aria(?:code)?)(?:还)?(?:有|具备|支持)(?:哪些|什么)(?:能力|功能|用途)(?:吗|呢)?", chinese):
+        return True
+    if re.fullmatch(r"(?:介绍|说明)(?:一下)?(?:你|您|aria(?:code)?)(?:的)?(?:能力|功能|用途)", chinese):
+        return True
+    return bool(re.fullmatch(
+        r"(?:(?:besides|apart from|other than) [^.!?;]+[,，]? )?"
+        r"what (?:else |other things )?can you (?:(?:help me )?(?:do|help with)|help me with)"
+        r"(?: (?:besides|apart from|other than) [^.!?;]+)?"
+        r"|what are your (?:capabilities|features)", text,
+    ))
+
+
+def is_conversation_only_message(message: str) -> bool:
+    return is_social_message(message) or is_capability_question(message)

aria_code/apps/cli/deterministic.py

@@ -0,0 +1,200 @@
+"""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,
+)
+from aria_code.packages.aria_services.research_protocol import requires_financial_evidence
+
+
+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``.
+    """
+
+    from aria_code.apps.cli.conversation_policy import is_capability_question
+    if is_capability_question(message):
+        return {"success": False}
+    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)
+
+    # The evidence gate refuses a market answer given without data, and a
+    # model with no tools cannot fetch any — so whatever the gate will demand
+    # data for is fetched here, in any wording ("How's NVDA this week?" as
+    # well as "分析苹果股票").
+    if not deterministic.get("success") and not config.model_has_tools:
+        deterministic = _try_handle_market_snapshot_analysis(
+            message, history=history, evidence_required=requires_financial_evidence(message))
+
+    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
+