aria-code 0.167.0__py3-none-win_amd64.whl

aria_code/packages/aria_services/references.py

@@ -0,0 +1,247 @@
+"""Typed, read-only ``@`` context references for Aria inputs.
+
+``/`` selects an operation. ``@`` selects context for that operation or for a
+natural-language request.  This service deliberately has no terminal or LLM
+dependency so the CLI, SDK, and future clients share the same semantics.
+"""
+
+from __future__ import annotations
+
+import os
+import re
+import shlex
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Iterable, Iterator, Sequence
+
+
+@dataclass(frozen=True)
+class ReferenceKind:
+    name: str
+    label_en: str
+    label_zh: str
+    filesystem: bool = False
+
+
+REFERENCE_KINDS: tuple[ReferenceKind, ...] = (
+    ReferenceKind("file", "File", "文件", filesystem=True),
+    ReferenceKind("folder", "Folder", "目录", filesystem=True),
+    ReferenceKind("asset", "Market asset", "市场资产"),
+    ReferenceKind("portfolio", "Portfolio", "投资组合", filesystem=True),
+    ReferenceKind("strategy", "Strategy", "策略", filesystem=True),
+    ReferenceKind("dataset", "Dataset", "数据集", filesystem=True),
+    ReferenceKind("run", "Research run", "研究运行", filesystem=True),
+    ReferenceKind("report", "Report", "报告", filesystem=True),
+)
+
+_KIND_MAP = {item.name: item for item in REFERENCE_KINDS}
+_REF_RE = re.compile(
+    r"(?<![\w@])@(?:(?P<kind>[A-Za-z][A-Za-z0-9_-]*):)?"
+    r"(?P<value>\"[^\"\n]+\"|'[^'\n]+'|[^\s@]+)"
+)
+_TRAILING_PUNCTUATION = ",;!?，。；！？)]}"
+_ASSET_RE = re.compile(r"^[A-Za-z0-9^._=-]{1,32}$")
+_RESOURCE_DIRS = {
+    "portfolio": ("portfolios",),
+    "strategy": ("strategies",),
+    "dataset": ("datasets", "data"),
+    "run": ("runs", "reports"),
+    "report": ("reports", "generated"),
+}
+_RESOURCE_EXTENSIONS = ("", ".md", ".json", ".yaml", ".yml", ".toml", ".csv", ".html")
+
+
+def reference_search_roots(kind: str, workspace: Path, output_root: Path | None = None) -> tuple[Path, ...]:
+    """Return deterministic search roots used by resolution and completion."""
+    roots: list[Path] = []
+    for name in _RESOURCE_DIRS.get(kind, ()):
+        roots.extend((workspace / ".aria" / name, workspace / name))
+        if output_root:
+            roots.append(output_root / name)
+    return tuple(dict.fromkeys(roots))
+
+
+@dataclass(frozen=True)
+class ReferencePolicy:
+    workspace: Path = field(default_factory=Path.cwd)
+    output_root: Path | None = None
+    allowed_roots: tuple[Path, ...] = ()
+
+    def normalized(self) -> "ReferencePolicy":
+        workspace = self.workspace.expanduser().resolve()
+        output_root = self.output_root.expanduser().resolve() if self.output_root else None
+        roots = [workspace]
+        if output_root:
+            roots.append(output_root)
+        roots.extend(path.expanduser().resolve() for path in self.allowed_roots)
+        return ReferencePolicy(
+            workspace=workspace,
+            output_root=output_root,
+            allowed_roots=tuple(dict.fromkeys(roots)),
+        )
+
+
+@dataclass(frozen=True)
+class ContextReference:
+    raw: str
+    kind: str
+    value: str
+    start: int
+    end: int
+    resolved_value: str = ""
+    path: Path | None = None
+    error: str = ""
+
+    @property
+    def ok(self) -> bool:
+        return not self.error
+
+
+@dataclass(frozen=True)
+class PreparedReferences:
+    original_text: str
+    expanded_text: str
+    context_block: str
+    references: tuple[ContextReference, ...]
+
+    @property
+    def errors(self) -> tuple[ContextReference, ...]:
+        return tuple(ref for ref in self.references if ref.error)
+
+    @property
+    def prompt(self) -> str:
+        if not self.context_block:
+            return self.expanded_text
+        return f"{self.expanded_text}\n\n{self.context_block}"
+
+
+def iter_reference_tokens(text: str) -> Iterator[tuple[str, str, str, int, int]]:
+    """Yield ``(raw, kind, value, start, end)`` while ignoring email addresses."""
+    for match in _REF_RE.finditer(text):
+        kind = (match.group("kind") or "file").lower()
+        token = match.group("value")
+        end = match.end()
+        if token[:1] in {"\"", "'"} and token[-1:] == token[:1]:
+            value = token[1:-1]
+        else:
+            trailing = _TRAILING_PUNCTUATION + ("." if kind not in {"file", "folder"} else "")
+            value = token.rstrip(trailing)
+            end -= len(token) - len(value)
+        if value:
+            yield text[match.start():end], kind, value, match.start(), end
+
+
+class ReferenceService:
+    """Resolve and prepare explicit context references without side effects."""
+
+    def __init__(self, policy: ReferencePolicy | None = None):
+        self.policy = (policy or ReferencePolicy()).normalized()
+
+    def prepare(self, text: str) -> PreparedReferences:
+        refs = tuple(self._resolve(*token) for token in iter_reference_tokens(text))
+        expanded = text
+        for ref in reversed(refs):
+            if not ref.ok:
+                continue
+            replacement = self._replacement(ref)
+            expanded = expanded[:ref.start] + replacement + expanded[ref.end:]
+
+        blocks: list[str] = []
+        for ref in refs:
+            if not ref.ok:
+                continue
+            target = str(ref.path) if ref.path is not None else ref.resolved_value
+            if ref.kind == "folder":
+                action = "Inspect on demand with list_files or search_code."
+            elif ref.kind == "asset":
+                action = "Fetch on demand with get_market_data or get_market_history."
+            else:
+                action = "Inspect on demand with read_file or analyze_file."
+            blocks.append(f"- {ref.kind}: {target}\n  {action}")
+
+        context_block = ""
+        if blocks:
+            context_block = (
+                "[Aria resource references - pointers only]\n"
+                "No resource content is preloaded. Use the named tools before answering.\n"
+                + "\n".join(blocks)
+                + "\n[End Aria resource references]"
+            )
+        return PreparedReferences(text, expanded, context_block, refs)
+
+    def _resolve(self, raw: str, kind: str, value: str, start: int, end: int) -> ContextReference:
+        if kind not in _KIND_MAP:
+            valid = ", ".join(item.name for item in REFERENCE_KINDS)
+            return ContextReference(raw, kind, value, start, end, error=f"unknown reference type '{kind}' (use: {valid})")
+        if kind == "asset":
+            if not _ASSET_RE.fullmatch(value):
+                return ContextReference(raw, kind, value, start, end, error=f"invalid market asset '{value}'")
+            return ContextReference(raw, kind, value, start, end, resolved_value=value.upper())
+
+        path = self._resolve_path(kind, value)
+        if path is None:
+            return ContextReference(raw, kind, value, start, end, error=f"{kind} not found: {value}")
+        if not self._is_allowed(path):
+            return ContextReference(raw, kind, value, start, end, path=path, error=f"reference is outside the allowed workspace: {value}")
+        if kind == "folder" and not path.is_dir():
+            return ContextReference(raw, kind, value, start, end, path=path, error=f"folder not found: {value}")
+        if kind != "folder" and not path.is_file():
+            return ContextReference(raw, kind, value, start, end, path=path, error=f"{kind} is not a file: {value}")
+
+        return ContextReference(
+            raw, kind, value, start, end,
+            resolved_value=str(path), path=path,
+        )
+
+    def _resolve_path(self, kind: str, value: str) -> Path | None:
+        if kind in {"file", "folder"}:
+            candidate = Path(os.path.expandvars(value)).expanduser()
+            if not candidate.is_absolute():
+                candidate = self.policy.workspace / candidate
+            try:
+                return candidate.resolve()
+            except OSError:
+                return None
+
+        for root in self._resource_roots(kind):
+            for suffix in _RESOURCE_EXTENSIONS:
+                candidate = root / f"{value}{suffix}"
+                if candidate.exists():
+                    return candidate.resolve()
+            if not root.is_dir():
+                continue
+            target_names = {value.lower(), *(f"{value}{suffix}".lower() for suffix in _RESOURCE_EXTENSIONS if suffix)}
+            seen = 0
+            for candidate in root.rglob("*"):
+                seen += 1
+                if seen > 2_000:
+                    break
+                if candidate.is_file() and (candidate.name.lower() in target_names or candidate.stem.lower() == value.lower()):
+                    return candidate.resolve()
+        return None
+
+    def _resource_roots(self, kind: str) -> Iterable[Path]:
+        yield from reference_search_roots(kind, self.policy.workspace, self.policy.output_root)
+
+    def _is_allowed(self, path: Path) -> bool:
+        resolved = path.resolve()
+        return any(resolved == root or root in resolved.parents for root in self.policy.allowed_roots)
+
+    def _replacement(self, ref: ContextReference) -> str:
+        if ref.kind == "asset":
+            return ref.resolved_value
+        if ref.path is not None:
+            return shlex.quote(str(ref.path)) if " " in str(ref.path) else str(ref.path)
+        return ref.resolved_value
+
+def build_reference_service(
+    *,
+    workspace: Path | None = None,
+    output_root: Path | None = None,
+    allowed_roots: Sequence[Path] = (),
+) -> ReferenceService:
+    return ReferenceService(ReferencePolicy(
+        workspace=workspace or Path.cwd(),
+        output_root=output_root,
+        allowed_roots=tuple(allowed_roots),
+    ))

aria_code/packages/aria_services/registry.py

@@ -0,0 +1,249 @@
+"""Product-level service contracts for Aria Code.
+
+These manifests describe stable service boundaries. They intentionally wrap the
+current modules instead of moving code all at once, so the CLI can migrate away
+from the large legacy entrypoint incrementally.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Dict, List
+
+from aria_code.packages.aria_core import CapabilityManifest, PackageLink, PermissionLevel, ServiceKind
+
+
+@dataclass(frozen=True)
+class ServiceSpec:
+    name: str
+    description: str
+    owner_package: str
+    module: str
+    capabilities: List[str] = field(default_factory=list)
+    permissions: List[PermissionLevel] = field(default_factory=list)
+    required: bool = True
+    migration_target: str = ""
+
+    def manifest(self) -> CapabilityManifest:
+        tags = ["service"]
+        if self.required:
+            tags.append("required")
+        return CapabilityManifest(
+            name=self.name,
+            kind=ServiceKind.DATA if self.name == "data" else ServiceKind.SERVICE,
+            description=self.description,
+            capabilities=self.capabilities,
+            permissions=self.permissions,
+            package_link=PackageLink(
+                package=self.owner_package,
+                module=self.module,
+                object_name=self.migration_target,
+                notes="Facade over existing modules; migrate implementation behind this boundary.",
+            ),
+            tags=tags,
+        )
+
+
+def list_service_specs() -> List[ServiceSpec]:
+    """Return stable service boundaries for the Aria Code product."""
+
+    return [
+        ServiceSpec(
+            name="gateway",
+            description="Local-first control plane for CLI, daemon, MCP, and channel entrypoints.",
+            owner_package="packages.aria_services",
+            module="apps.gateway",
+            capabilities=["session.routing", "task.queue", "mcp.routing", "channel.routing"],
+            permissions=[PermissionLevel.READ_ONLY, PermissionLevel.WORKSPACE_WRITE],
+            migration_target="GatewayService",
+        ),
+        ServiceSpec(
+            name="runtime",
+            description="Agent turn loop, tool execution, approvals, traces, and parallel tool orchestration.",
+            owner_package="runtime",
+            module="runtime",
+            capabilities=["agent.loop", "tool.execution", "approval.policy", "trace"],
+            permissions=[PermissionLevel.READ_ONLY, PermissionLevel.WORKSPACE_WRITE],
+            migration_target="AgentRuntime",
+        ),
+        ServiceSpec(
+            name="settings",
+            description="Configuration, secrets, model profiles, runtime flags, and permission policy resolution.",
+            owner_package="packages.aria_services",
+            module="packages.aria_services.settings",
+            capabilities=[
+                "settings.config",
+                "settings.secrets",
+                "settings.model_profiles",
+                "settings.permission_policy",
+            ],
+            permissions=[PermissionLevel.READ_ONLY],
+            migration_target="SettingsService",
+        ),
+        ServiceSpec(
+            name="context",
+            description="Conversation memory, context pressure checks, compaction, and resumable summary envelopes.",
+            owner_package="packages.aria_services",
+            module="packages.aria_services.context",
+            capabilities=[
+                "context.memory",
+                "context.compaction",
+                "context.resume",
+                "context.checkpoint",
+            ],
+            permissions=[PermissionLevel.READ_ONLY, PermissionLevel.WORKSPACE_WRITE],
+            migration_target="ContextService",
+        ),
+        ServiceSpec(
+            name="references",
+            description="Typed read-only @ references for files, folders, assets, and research artifacts.",
+            owner_package="packages.aria_services",
+            module="packages.aria_services.references",
+            capabilities=[
+                "context.reference.parse",
+                "context.reference.resolve",
+                "context.reference.tool_plan",
+                "context.reference.complete",
+            ],
+            permissions=[PermissionLevel.READ_ONLY],
+            migration_target="ReferenceService",
+        ),
+        ServiceSpec(
+            name="tools",
+            description="Typed tool manifests, schemas, permissions, local tool adapters, and MCP tool conversion.",
+            owner_package="packages.aria_tools",
+            module="packages.aria_tools",
+            capabilities=[
+                "tool.registry",
+                "tool.schema",
+                "tool.permissions",
+                "tool.local_adapter",
+                "tool.mcp_adapter",
+            ],
+            permissions=[PermissionLevel.READ_ONLY, PermissionLevel.WORKSPACE_WRITE, PermissionLevel.NETWORK],
+            migration_target="ToolRegistry",
+        ),
+        ServiceSpec(
+            name="data",
+            description="Multi-source market data with timestamps, provider attribution, and stale-data flags.",
+            owner_package="packages.aria_services",
+            module="data_service",
+            capabilities=["market.quote", "market.history", "technical.indicators", "data.quality"],
+            permissions=[PermissionLevel.NETWORK],
+            migration_target="MarketDataService",
+        ),
+        ServiceSpec(
+            name="reports",
+            description="Report, chart, and artifact generation with local workspace storage policies.",
+            owner_package="packages.aria_services",
+            module="report_generator",
+            capabilities=[
+                "report.markdown",
+                "report.html",
+                "chart.render",
+                "artifact.storage",
+            ],
+            permissions=[PermissionLevel.READ_ONLY, PermissionLevel.WORKSPACE_WRITE],
+            migration_target="ReportService",
+        ),
+        ServiceSpec(
+            name="research_quality",
+            description="Deterministic report completion, plausibility, coverage, and provenance gates.",
+            owner_package="packages.aria_services",
+            module="packages.aria_services.research_quality",
+            capabilities=["report.quality_gate", "report.provenance", "report.plausibility"],
+            permissions=[PermissionLevel.READ_ONLY],
+            migration_target="ReportQualityAssessment",
+        ),
+        ServiceSpec(
+            name="brokers",
+            description="Broker account reads, paper trading, order previews, guarded execution, and audit trails.",
+            owner_package="brokers",
+            module="brokers",
+            capabilities=[
+                "broker.account",
+                "broker.positions",
+                "broker.orders",
+                "broker.paper",
+                "broker.trade_preview",
+                "broker.confirmed_execution",
+                "broker.audit",
+            ],
+            permissions=[PermissionLevel.BROKER_READ, PermissionLevel.BROKER_TRADE],
+            migration_target="BrokerService",
+        ),
+        ServiceSpec(
+            name="skills",
+            description="Workflow recipes that bind tools, agents, data, reports, and brokers.",
+            owner_package="packages.aria_skills",
+            module="packages.aria_skills",
+            capabilities=[
+                "skill.registry",
+                "skill.discovery",
+                "skill.metadata_route",
+                "skill.namespace",
+                "skill.integrity",
+                "skill.activation_trace",
+                "workflow.binding",
+            ],
+            permissions=[PermissionLevel.READ_ONLY],
+            migration_target="SkillRegistry",
+        ),
+        ServiceSpec(
+            name="mcp",
+            description="MCP server discovery, health, tool provenance, reconnect policy, and manifest conversion.",
+            owner_package="packages.aria_mcp",
+            module="packages.aria_mcp",
+            capabilities=[
+                "mcp.discovery",
+                "mcp.health",
+                "mcp.tool_manifests",
+                "mcp.reconnect",
+                "mcp.provenance",
+            ],
+            permissions=[PermissionLevel.READ_ONLY, PermissionLevel.NETWORK],
+            migration_target="MCPService",
+        ),
+        ServiceSpec(
+            name="channels",
+            description="Optional external entrypoints such as daemon, relay, Feishu, Telegram, and webhooks.",
+            owner_package="apps.channels",
+            module="apps.channels",
+            capabilities=["channel.daemon", "channel.relay", "channel.feishu", "channel.telegram"],
+            permissions=[PermissionLevel.NETWORK],
+            required=False,
+            migration_target="ChannelRegistry",
+        ),
+        ServiceSpec(
+            name="safety",
+            description="Sandbox, workspace permissions, command policy, privacy controls, and audit hooks.",
+            owner_package="safety",
+            module="safety",
+            capabilities=["sandbox", "command.policy", "privacy", "audit"],
+            permissions=[PermissionLevel.READ_ONLY],
+            migration_target="SafetyService",
+        ),
+        ServiceSpec(
+            name="observability",
+            description="Doctor checks, runtime traces, provider health, architecture coverage, and support bundles.",
+            owner_package="packages.aria_infra",
+            module="packages.aria_infra.doctor",
+            capabilities=[
+                "doctor.checks",
+                "trace.export",
+                "provider.health",
+                "architecture.coverage",
+                "support.bundle",
+            ],
+            permissions=[PermissionLevel.READ_ONLY, PermissionLevel.WORKSPACE_WRITE],
+            migration_target="ObservabilityService",
+        ),
+    ]
+
+
+def service_map() -> Dict[str, ServiceSpec]:
+    return {service.name: service for service in list_service_specs()}
+
+
+def required_service_names() -> List[str]:
+    return [service.name for service in list_service_specs() if service.required]

aria_code/packages/aria_services/research_protocol.py

@@ -0,0 +1,137 @@
+"""Financial-research grounding policy shared by Aria adapters."""
+
+from __future__ import annotations
+
+import re
+from collections.abc import Iterable, Mapping
+
+
+_MARKET_IDENTIFIER = re.compile(
+    r"\b[A-Z]{1,5}(?:\.[A-Z]{1,4})?\b|\b\d{6}(?:\.(?:SH|SZ|SS|HK))?\b"
+)
+# Words that name a financial subject on their own. Everyday words used to be
+# in this list too — market, share, option, volume, price, holding, fund, and
+# 市场, 组合, 加密 — so "analyze the performance of the share button", "how is
+# option parsing doing", "分析一下这个项目的市场定位" and "分析当前加密算法的风险"
+# (加密 alone is encryption) were all gated as market questions, and refused
+# after the turn had already done its real work, because no market-data tool
+# had run. Only terms that mean finance wherever they appear belong here.
+_FINANCIAL_SUBJECTS = (
+    "stock", "equity", "equities", "portfolio", "crypto", "bitcoin", "forex",
+    "etf", "dividend", "earnings", "ticker", "share price", "stock market",
+    "market cap", "trading volume", "bond yield", "mutual fund", "index fund",
+    "hedge fund", "options chain", "call option", "put option", "price target",
+    "股票", "股价", "股市", "大盘", "a股", "美股", "港股", "行情", "持仓", "基金",
+    "期权", "债券", "外汇", "加密货币", "数字货币", "币价", "成交量", "市值",
+    "财报", "基本面", "涨跌", "收盘价", "开盘价", "目标价",
+)
+
+# Words that are financial only some of the time: "how is the market doing
+# today" is a market question, "这个项目的市场定位" is not. They count when the
+# message asks about now and says nothing that places it in the user's own
+# product or code.
+_AMBIGUOUS_SUBJECTS = ("market", "price", "valuation", "市场", "价格", "估值")
+_TIME_INTENTS = (
+    "today", "current", "latest", "this week", "right now", "how's", "how is",
+    "doing", "今天", "当前", "最新", "本周", "这周", "近期", "现在", "走势", "怎么样",
+)
+_WORKSPACE_CONTEXT = (
+    "project", "product", "code", "app", "function", "button", "feature",
+    "repo", "file", "api", "cli", "page", "plan", "pricing", "subscription",
+    "competitor", "positioning", "user",
+    "项目", "产品", "代码", "函数", "功能", "页面", "应用", "仓库", "文件",
+    "定位", "竞品", "用户", "方案", "套餐",
+)
+
+_EVIDENCE_INTENTS = (
+    "analyze", "analysis", "forecast", "predict", "recommend", "buy", "sell",
+    "current", "latest", "today", "trend", "risk", "target", "outlook",
+    "this week", "how's", "how is", "doing", "performance",
+    "分析", "预测", "推荐", "买入", "卖出", "最新", "当前", "今天", "走势",
+    "趋势", "风险", "目标价", "前景", "成交量", "全面分析",
+    "本周", "这周", "近期", "怎么样", "表现", "看法", "值得",
+)
+_GROUNDING_TOOL_FRAGMENTS = (
+    "market", "quote", "price", "ohlcv", "fundamental", "filing", "news",
+    "factor", "risk", "backtest", "portfolio", "prediction", "signal",
+    "regime", "financial", "earnings", "valuation", "macro", "flow",
+)
+
+
+def _mentions(lowered: str, terms: Iterable[str]) -> bool:
+    """Whether any term occurs — as a word for English, as a substring for CJK.
+
+    Substrings are wrong for short English words in both directions: "market"
+    is inside "marketing" and "equity" inside "inequity", while "app" is inside
+    "happening" and "api" inside "capital". Chinese has no spaces to bound a
+    word, so it keeps substring matching.
+    """
+    for term in terms:
+        if term.isascii():
+            if re.search(rf"(?<![a-z]){re.escape(term)}(?![a-z])", lowered):
+                return True
+        elif term in lowered:
+            return True
+    return False
+
+
+def _names_an_instrument(text: str) -> bool:
+    """A ticker, code or company the finance pack recognises, or a named company.
+
+    This used to be a bare regex, \\b[A-Z]{1,5}\\b: it took "API" and "CSV"
+    for tickers ("analyze the API latency trend" was gated as a market
+    question and refused without market data), and missed "分析AAPL" — no word
+    boundary between 析 and A — and every company named in Chinese.
+    """
+    try:
+        from aria_code.packs import activate_packs, load_builtin_packs
+
+        load_builtin_packs()
+        if any(a.pack == "finance" for a in activate_packs(text)):
+            return True
+    except Exception:
+        if _MARKET_IDENTIFIER.search(text):
+            return True
+    try:
+        from aria_code.apps.cli.intent_signals import _ENTITY_TERMS
+    except Exception:
+        return False
+    lowered = text.lower()
+    return any(term in lowered for term in _ENTITY_TERMS)
+
+
+def requires_financial_evidence(query: str) -> bool:
+    """Return whether a request needs current external financial evidence."""
+    text = str(query or "").strip()
+    if not text:
+        return False
+    from aria_code.apps.cli.conversation_policy import is_capability_question
+    if is_capability_question(text):
+        return False
+    lowered = text.lower()
+    if not any(term in lowered for term in _EVIDENCE_INTENTS):
+        return False
+    if _mentions(lowered, _FINANCIAL_SUBJECTS) or _names_an_instrument(text):
+        return True
+    return (
+        _mentions(lowered, _AMBIGUOUS_SUBJECTS)
+        and _mentions(lowered, _TIME_INTENTS)
+        and not _mentions(lowered, _WORKSPACE_CONTEXT)
+    )
+
+
+def grounding_tool_names(tool_schemas: Iterable[Mapping]) -> frozenset[str]:
+    """Select registered tools whose outputs can ground a financial conclusion."""
+    names: set[str] = set()
+    for schema in tool_schemas:
+        function = schema.get("function") if isinstance(schema, Mapping) else None
+        name = str(
+            (function or {}).get("name")
+            if isinstance(function, Mapping)
+            else schema.get("name", "")
+        )
+        canonical = name.rsplit("__", 1)[-1].lower()
+        if name and any(fragment in canonical for fragment in _GROUNDING_TOOL_FRAGMENTS):
+            names.add(name)
+    return frozenset(names)
+