aria-code 0.167.0__py3-none-win_amd64.whl

aria_code/packages/aria_services/research_quality.py

@@ -0,0 +1,186 @@
+"""Deterministic completion gates for multi-agent research reports."""
+
+from __future__ import annotations
+
+from dataclasses import asdict, dataclass, field
+from datetime import datetime, timezone
+from enum import Enum
+from typing import Any, Iterable
+
+
+class ReportQualityDecision(str, Enum):
+    COMPLETE = "complete"
+    PARTIAL = "partial"
+    BLOCKED = "blocked"
+
+
+def _utc_timestamp() -> str:
+    return datetime.now(timezone.utc).isoformat(timespec="seconds")
+
+
+@dataclass(frozen=True)
+class ReportQualityPolicy:
+    min_agent_coverage: float = 0.60
+    min_core_coverage: float = 2 / 3
+    core_agents: tuple[str, ...] = ("technical", "fundamental", "risk")
+    max_degraded_ratio: float = 0.50
+    require_quote: bool = True
+    allow_stale: bool = False
+    max_market_cap: float = 100_000_000_000_000.0
+    max_implied_shares: float = 100_000_000_000.0
+
+
+@dataclass(frozen=True)
+class ReportQualityAssessment:
+    decision: ReportQualityDecision
+    requested_agents: tuple[str, ...]
+    usable_agents: tuple[str, ...]
+    degraded_agents: tuple[str, ...]
+    failed_agents: tuple[str, ...]
+    agent_coverage: float
+    core_coverage: float
+    reasons: tuple[str, ...] = field(default_factory=tuple)
+    warnings: tuple[str, ...] = field(default_factory=tuple)
+    blocking_reasons: tuple[str, ...] = field(default_factory=tuple)
+    assessed_at: str = field(default_factory=_utc_timestamp)
+
+    @property
+    def metadata_status(self) -> str:
+        if self.decision is ReportQualityDecision.BLOCKED:
+            return "data_unavailable"
+        return self.decision.value
+
+    def to_dict(self) -> dict[str, Any]:
+        data = asdict(self)
+        data["decision"] = self.decision.value
+        data["metadata_status"] = self.metadata_status
+        data["core_agent_coverage"] = data["core_coverage"]
+        data["_contract_type"] = "ResearchQualityAssessment"
+        data["_contract_version"] = "1.0.0"
+        return data
+
+
+def _as_float(value: Any) -> float | None:
+    try:
+        if value in (None, ""):
+            return None
+        return float(value)
+    except (TypeError, ValueError):
+        return None
+
+
+def _unique(values: Iterable[str]) -> tuple[str, ...]:
+    return tuple(dict.fromkeys(value for value in values if value))
+
+
+def assess_team_report(
+    team_result: Any,
+    data_bundle: Any = None,
+    policy: ReportQualityPolicy | None = None,
+) -> ReportQualityAssessment:
+    """Assess whether a report is complete, usable with caveats, or blocked."""
+    policy = policy or ReportQualityPolicy()
+    requested = _unique(
+        str(name)
+        for name in (getattr(team_result, "agents_run", None) or [])
+        if name not in {"synthesis", "debate"}
+    )
+    results = list(getattr(team_result, "results", None) or [])
+    if not requested:
+        requested = _unique(
+            str(getattr(result, "agent", ""))
+            for result in results
+            if getattr(result, "agent", "") not in {"synthesis", "debate"}
+        )
+
+    result_by_agent = {
+        str(getattr(result, "agent", "")): result
+        for result in results
+        if getattr(result, "agent", "")
+    }
+    usable = _unique(
+        name
+        for name in requested
+        if name in result_by_agent
+        and bool(getattr(result_by_agent[name], "success", False))
+        and bool(str(getattr(result_by_agent[name], "analysis", "") or "").strip())
+    )
+    degraded = _unique(
+        name for name in usable if bool(getattr(result_by_agent[name], "degraded", False))
+    )
+    failed = _unique(name for name in requested if name not in usable)
+    coverage = len(usable) / len(requested) if requested else 0.0
+    expected_core = tuple(name for name in policy.core_agents if name in requested)
+    core_coverage = (
+        sum(1 for name in expected_core if name in usable) / len(expected_core)
+        if expected_core else 1.0
+    )
+
+    warnings: list[str] = []
+    blocking: list[str] = []
+    reasons: list[str] = []
+
+    quote = dict(getattr(data_bundle, "quote", {}) or {}) if data_bundle else {}
+    price = _as_float(quote.get("price") or quote.get("current_price"))
+    volume = _as_float(quote.get("volume"))
+    market_cap = _as_float(quote.get("market_cap") or quote.get("marketCap"))
+    data_status = str(getattr(data_bundle, "status", "") or "").lower() if data_bundle else ""
+    stale = bool((getattr(data_bundle, "quality", {}) or {}).get("stale", False)) if data_bundle else False
+
+    if policy.require_quote and (price is None or price <= 0):
+        blocking.append("missing or invalid reference price")
+    if volume is not None and volume < 0:
+        blocking.append("negative volume")
+    if market_cap is not None:
+        if market_cap <= 0:
+            warnings.append("invalid market capitalization")
+        elif market_cap > policy.max_market_cap:
+            warnings.append("market capitalization exceeds plausibility limit")
+        if price and price > 0 and market_cap / price > policy.max_implied_shares:
+            warnings.append("implied share count exceeds plausibility limit")
+
+    if data_status in {"data_unavailable", "unavailable", "failed"}:
+        blocking.append("market data bundle unavailable")
+    elif data_status in {"partial", "stale"}:
+        warnings.append(f"market data status is {data_status}")
+    if stale and not policy.allow_stale:
+        warnings.append("market data is stale")
+    if not usable:
+        blocking.append("no agent produced usable analysis")
+    if coverage < policy.min_agent_coverage:
+        warnings.append(
+            f"agent coverage {coverage:.0%} is below {policy.min_agent_coverage:.0%}"
+        )
+    if core_coverage < policy.min_core_coverage:
+        warnings.append(
+            f"core-agent coverage {core_coverage:.0%} is below {policy.min_core_coverage:.0%}"
+        )
+    degraded_ratio = len(degraded) / len(usable) if usable else 0.0
+    if degraded_ratio > policy.max_degraded_ratio:
+        warnings.append(f"degraded-agent ratio {degraded_ratio:.0%} is too high")
+
+    if blocking:
+        decision = ReportQualityDecision.BLOCKED
+    elif warnings:
+        decision = ReportQualityDecision.PARTIAL
+    else:
+        decision = ReportQualityDecision.COMPLETE
+
+    reasons.append(f"usable agents: {len(usable)}/{len(requested)}")
+    if degraded:
+        reasons.append(f"degraded agents: {', '.join(degraded)}")
+    if failed:
+        reasons.append(f"failed agents: {', '.join(failed)}")
+
+    return ReportQualityAssessment(
+        decision=decision,
+        requested_agents=requested,
+        usable_agents=usable,
+        degraded_agents=degraded,
+        failed_agents=failed,
+        agent_coverage=round(coverage, 4),
+        core_coverage=round(core_coverage, 4),
+        reasons=_unique(reasons),
+        warnings=_unique(warnings),
+        blocking_reasons=_unique(blocking),
+    )

aria_code/packages/aria_services/settings.py

@@ -0,0 +1,160 @@
+"""SettingsService — single owner of persistent Aria configuration.
+
+This is the concrete implementation behind the ``settings`` ServiceSpec in
+``packages.aria_services.registry`` (capability ``settings.config``). It owns
+the merge/normalize/persist mechanics that previously lived in
+``apps/cli/config_store.py``; that module is now a thin CLI adapter which
+constructs this service with CLI-specific hooks.
+
+Layering: this package must stay importable by launcher, daemon, brokers and
+MCP without dragging in the CLI. Anything CLI-flavored (provider-name
+normalization, i18n language detection, model auto-selection, policy sync) is
+injected as an optional callable rather than imported from ``apps.cli``.
+"""
+
+from __future__ import annotations
+
+import json
+from collections.abc import Callable
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any, Optional
+
+
+# Models that no longer exist / were renamed; a saved config pointing at one
+# is silently reset to the caller's default so the CLI never boots into a
+# permanently-broken model selection.
+STALE_ARIA_MODEL_PREFIXES = ("aria-opus", "aria-prelude", "aria-sonata:3", "aria-sonata:4")
+
+# Keys that are session state, not configuration — never persisted.
+NEVER_PERSIST = frozenset({
+    "conversation_history", "_session_workspace_root", "_session_write_roots",
+    "_session_read_roots", "_workspace_transport",
+})
+
+
+@dataclass
+class SettingsService:
+    """Load, normalize, persist, and hand out the Aria config dict.
+
+    ``config_dir``/``config_file``/``sessions_dir`` duck-type
+    ``apps.cli.config_paths.AriaConfigPaths`` so the CLI can pass its existing
+    paths object fields straight through.
+    """
+
+    config_dir: Path
+    config_file: Path
+    sessions_dir: Path
+    defaults: dict = field(default_factory=dict)
+    # Optional environment hooks (all safe to omit):
+    normalize_provider: Optional[Callable[[str], str]] = None
+    detect_lang: Optional[Callable[[], str]] = None
+    # There was an auto_select_model hook here. It probed Ollama on first run
+    # and replaced the caller's default model with whatever was installed; see
+    # load(). Removed rather than left unwired, so it is not reconnected by
+    # someone who finds an unused hook and assumes it should be doing something.
+    on_loaded: Optional[Callable[[dict], None]] = None  # e.g. CLI policy sync
+    stale_model_prefixes: tuple = STALE_ARIA_MODEL_PREFIXES
+
+    _snapshot: Optional[dict] = field(default=None, repr=False)
+
+    # ── core API ─────────────────────────────────────────────────────────────
+
+    def load(self) -> dict:
+        """Read config file, merge over defaults, normalize, fire on_loaded."""
+        self.config_dir.mkdir(parents=True, exist_ok=True)
+        self.sessions_dir.mkdir(parents=True, exist_ok=True)
+        if self.config_file.exists():
+            try:
+                saved = json.loads(self.config_file.read_text(encoding="utf-8"))
+                merged = {**self.defaults, **saved}
+                self._infer_local_provider(merged, saved)
+                self._reset_stale_model(merged)
+                self._ensure_ui_lang(merged)
+                self._finish_load(merged)
+                return merged
+            except Exception:
+                pass
+
+        # First run: the defaults stand as written. This used to probe Ollama
+        # here and overwrite cfg["model"] with whatever was installed, which
+        # contradicted the comment above DEFAULT_MODEL in apps/cli/bootstrap.py
+        # -- "provider configuration is the user's to make ... the code's job is
+        # to have a sane default and then get out of the way". It also cost a
+        # 3s HTTP timeout on every first start, and it was not needed for
+        # discoverability: the banner already reports "Ollama online · N models"
+        # (ui/banner.ollama_status_label), so a user with local models can see
+        # them and run /model.
+        cfg = dict(self.defaults)
+        try:
+            if self.detect_lang is not None:
+                cfg["ui_lang"] = self.detect_lang()
+        except Exception:
+            cfg["ui_lang"] = "en"
+        cfg.setdefault("ui_lang", "en")
+        self._finish_load(cfg)
+        return cfg
+
+    def save(self, cfg: dict) -> None:
+        self.config_dir.mkdir(parents=True, exist_ok=True)
+        payload = {k: v for k, v in cfg.items() if k not in NEVER_PERSIST}
+        # config.json holds auth_token / refresh_token from /login, so it is
+        # written owner-only like the other credential files.
+        from aria_code.packages.aria_core.secure_file import write_secret_json
+
+        write_secret_json(self.config_file, payload)
+        self._snapshot = dict(cfg)
+
+    def get(self, key: str, default: Any = None) -> Any:
+        """Read one key from the last-loaded snapshot (loads on first use)."""
+        if self._snapshot is None:
+            self.load()
+        return self._snapshot.get(key, default)
+
+    def set(self, key: str, value: Any) -> dict:
+        """Update one key and persist immediately; returns the new snapshot."""
+        if self._snapshot is None:
+            self.load()
+        cfg = dict(self._snapshot)
+        cfg[key] = value
+        self.save(cfg)
+        return cfg
+
+    def snapshot(self) -> dict:
+        """The last-loaded/saved config dict (loads on first use)."""
+        if self._snapshot is None:
+            self.load()
+        return dict(self._snapshot)
+
+    # ── normalization steps (extracted verbatim from the CLI loader) ─────────
+
+    def _infer_local_provider(self, merged: dict, saved: dict) -> None:
+        saved_model = merged.get("model", "")
+        if "local_provider" not in saved:
+            merged["local_provider"] = (
+                saved_model.split("/", 1)[0].lower() if "/" in saved_model else "ollama"
+            )
+        if self.normalize_provider is not None:
+            try:
+                merged["local_provider"] = (
+                    self.normalize_provider(merged.get("local_provider")) or "ollama"
+                )
+            except Exception:
+                pass
+
+    def _reset_stale_model(self, merged: dict) -> None:
+        model = merged.get("model", "")
+        if any(model.startswith(p) for p in self.stale_model_prefixes):
+            merged["model"] = self.defaults.get("model", "")
+
+    def _ensure_ui_lang(self, merged: dict) -> None:
+        if not merged.get("ui_lang"):
+            try:
+                merged["ui_lang"] = self.detect_lang() if self.detect_lang else "en"
+            except Exception:
+                merged["ui_lang"] = "en"
+
+    def _finish_load(self, cfg: dict) -> None:
+        self._snapshot = dict(cfg)
+        if self.on_loaded is not None:
+            self.on_loaded(cfg)

aria_code/packages/aria_services/usage.py

@@ -0,0 +1,151 @@
+"""User-facing service usage catalog for Aria Code."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True)
+class ServiceUsageSpec:
+    name: str
+    purpose: str
+    cli_entrypoints: tuple[str, ...]
+    package_sources: tuple[str, ...]
+    mcp_tools: tuple[str, ...]
+    next_step: str
+
+
+def list_service_usage_specs() -> tuple[ServiceUsageSpec, ...]:
+    """Return how each project service is meant to be used from Aria."""
+
+    return (
+        ServiceUsageSpec(
+            name="agent_runtime",
+            purpose="模型回合、工具调用、并行/串行执行、审批、取消、LoopGuard 和 trace",
+            cli_entrypoints=("/chat", "-p", "aria"),
+            package_sources=("runtime", "packages/aria_sdk", "apps/cli/providers/runtime_bridge.py"),
+            mcp_tools=("aria.agent.run", "aria.tools.execute"),
+            next_step="/architecture --gaps 查看 runtime cutover 状态",
+        ),
+        ServiceUsageSpec(
+            name="settings_config",
+            purpose="模型配置、provider key、权限模式、网络开关、语言和 UI 偏好",
+            cli_entrypoints=("/config", "/model", "/apikey", "/setup"),
+            package_sources=("apps/cli/config_store.py", "apps/cli/config_paths.py", "config"),
+            mcp_tools=(),
+            next_step="/config list 或 /setup",
+        ),
+        ServiceUsageSpec(
+            name="context_memory",
+            purpose="上下文压力检测、自动压缩、会话恢复和用户偏好记忆",
+            cli_entrypoints=("/compact", "/memory", "/session"),
+            package_sources=("packages/aria_services/context.py", "apps/cli/message_processing.py"),
+            mcp_tools=("aria.context.compact",),
+            next_step="/status 查看 auto compact 状态",
+        ),
+        ServiceUsageSpec(
+            name="context_references",
+            purpose="使用 @ 将文件、目录、市场资产和研究产物作为只读上下文附加到请求",
+            cli_entrypoints=("@file:", "@folder:", "@asset:", "@portfolio:", "@strategy:", "@dataset:", "@run:", "@report:"),
+            package_sources=("packages/aria_services/references.py", "ui/completer.py"),
+            mcp_tools=(),
+            next_step="输入 @ 查看类型，或使用 /risk @portfolio:core",
+        ),
+        ServiceUsageSpec(
+            name="tool_registry",
+            purpose="本地工具、MCP 工具、schema、权限和 deterministic 输出封装",
+            cli_entrypoints=("/tools", "/mcp", "!shell"),
+            package_sources=("packages/aria_tools", "packages/aria_mcp", "runtime/tool_executor.py"),
+            mcp_tools=("read_file", "run_command", "broker_order"),
+            next_step="/tools 或 /packages tools arthera",
+        ),
+        ServiceUsageSpec(
+            name="market_data",
+            purpose="行情、历史K线、技术指标、数据质量标记",
+            cli_entrypoints=("/quote", "/market", "/ta", "/chart"),
+            package_sources=("packages/data", "packages/quant_engine"),
+            mcp_tools=("calculate_factors", "northbound_flow"),
+            next_step="/quote AAPL 或 /chart MC.PA 1y",
+        ),
+        ServiceUsageSpec(
+            name="signals_prediction",
+            purpose="量化信号、预测收益、市场状态和仓位建议",
+            cli_entrypoints=("/signal", "/predict", "/team"),
+            package_sources=("packages/quant_engine", "packages/ml"),
+            mcp_tools=("generate_signal", "get_ai_signal", "get_predictions", "kelly_position"),
+            next_step="/signal NVDA 或 /packages tools arthera",
+        ),
+        ServiceUsageSpec(
+            name="backtest",
+            purpose="策略回测、交易成本、胜率、夏普和最大回撤",
+            cli_entrypoints=("/backtest", "/strategy"),
+            package_sources=("packages/quant_engine/backtest",),
+            mcp_tools=("run_backtest",),
+            next_step="/backtest momentum NVDA --period 1y",
+        ),
+        ServiceUsageSpec(
+            name="risk_portfolio",
+            purpose="持仓风险、组合风险、压力测试和资金管理",
+            cli_entrypoints=("/risk", "/positions", "/account"),
+            package_sources=("brokers", "packages/quant_engine/risk", "packages/contracts"),
+            mcp_tools=("detect_regime", "kelly_position"),
+            next_step="/broker guide 然后 /positions",
+        ),
+        ServiceUsageSpec(
+            name="reports_artifacts",
+            purpose="研报、图表、看板、Pine 文件、完成度门禁和本地 artifact 管理",
+            cli_entrypoints=("/report", "/dashboard", "/chart", "/tv", "/artifacts"),
+            package_sources=("packages/reporting", "artifacts"),
+            mcp_tools=(
+                "aria.report.generate",
+                "aria.artifacts.list",
+                "research_report_assess",
+                "research_run_record_quality",
+            ),
+            next_step="/report MSFT --format html",
+        ),
+        ServiceUsageSpec(
+            name="broker_execution",
+            purpose="券商连接、账户只读查询、仿盘账户、订单预览、确认后执行和审计",
+            cli_entrypoints=("/broker", "/paper", "/trade", "/account", "/positions", "/orders"),
+            package_sources=("brokers", "brokers/trading.py", "brokers/paper_broker.py"),
+            mcp_tools=("broker_query", "broker_order"),
+            next_step="/paper start 100000 USD 或 /broker doctor",
+        ),
+        ServiceUsageSpec(
+            name="tradingview_webhook",
+            purpose="TradingView 图表打开、Pine 策略导出、Alert Webhook 接入",
+            cli_entrypoints=("/tv", "aria_daemon.py"),
+            package_sources=("apps/cli/tradingview_bridge.py", "aria_daemon.py"),
+            mcp_tools=(),
+            next_step="/tv NVDA --pine --txt",
+        ),
+        ServiceUsageSpec(
+            name="mcp_bridge",
+            purpose="把 Arthera QuantEngine 作为 MCP 工具暴露给 Aria/Claude/Cursor",
+            cli_entrypoints=("/packages connect arthera", "/mcp reload", "/packages tools arthera"),
+            package_sources=("packages/quant_engine/mcp_server.py",),
+            mcp_tools=("calculate_factors", "run_backtest", "price_option", "execution_schedule"),
+            next_step="/packages connect arthera --reload",
+        ),
+        ServiceUsageSpec(
+            name="safety_policy",
+            purpose="文件、shell、网络、券商交易和隐私反馈的统一权限/审计边界",
+            cli_entrypoints=("/permissions", "/trade preview", "/feedback"),
+            package_sources=("safety", "runtime/approval.py", "command_safety.py", "privacy"),
+            mcp_tools=("run_command", "broker_order"),
+            next_step="/permissions 或 /trade mode",
+        ),
+        ServiceUsageSpec(
+            name="observability",
+            purpose="doctor、架构覆盖、数据源健康、trace、manifest 和支持包",
+            cli_entrypoints=("/doctor", "/architecture", "/packages doctor"),
+            package_sources=("packages/aria_infra", "packages/aria_services/provider_health.py"),
+            mcp_tools=("aria.health", "aria.manifest.export"),
+            next_step="/doctor 或 /architecture --gaps",
+        ),
+    )
+
+
+def service_usage_map() -> dict[str, ServiceUsageSpec]:
+    return {spec.name: spec for spec in list_service_usage_specs()}

aria_code/packages/aria_skills/__init__.py

@@ -0,0 +1,46 @@
+"""Skill registry facade."""
+
+from .registry import SkillSpec, builtin_skill_specs
+from .catalog import (
+    CatalogInstallResult,
+    CatalogSource,
+    catalog_clone_command,
+    default_catalog_home,
+    install_catalog,
+    parse_catalog_source,
+)
+from .loader import (
+    LoadedSkill,
+    SkillActivation,
+    SkillActivationTrace,
+    SkillPolicy,
+    activate_external_skills,
+    build_skill_prompt_block,
+    default_skill_roots,
+    discover_external_skills,
+    recent_skill_activation_traces,
+    select_external_skills,
+    skill_tree_sha256,
+)
+
+__all__ = [
+    "CatalogInstallResult",
+    "CatalogSource",
+    "LoadedSkill",
+    "SkillActivation",
+    "SkillActivationTrace",
+    "SkillPolicy",
+    "SkillSpec",
+    "activate_external_skills",
+    "build_skill_prompt_block",
+    "builtin_skill_specs",
+    "catalog_clone_command",
+    "default_catalog_home",
+    "default_skill_roots",
+    "discover_external_skills",
+    "install_catalog",
+    "parse_catalog_source",
+    "recent_skill_activation_traces",
+    "select_external_skills",
+    "skill_tree_sha256",
+]