aria-code 0.52.0__py3-none-any.whl

aria_code/packs/payments/__init__.py

@@ -0,0 +1,139 @@
+"""Payments — Stripe objects.
+
+The cleanest case the pack contract has.  Stripe object ids carry a typed
+prefix (``ch_`` charge, ``pi_`` payment intent, ``cus_`` customer, ``sub_``
+subscription…) followed by a long opaque suffix, so recognising one is a
+resolution rather than a guess: nothing else in an English or Chinese sentence
+looks like ``pi_3PqR8s2eZvKYlo2C0aBcDeFg``.
+
+That precision is what lets this pack stay registered permanently at no cost.
+It cannot fire on domain vocabulary — the words "payment", "refund" and
+"订阅" never activate it — so a payments deployment adds nothing to the latency
+or the failure surface of a session about anything else.
+"""
+
+from __future__ import annotations
+
+import re
+from typing import Sequence
+
+from aria_code.packs.base import BaseDomainPack, EntityMatch, PackActivation
+
+PACK_NAME = "payments"
+
+PAYMENT_TOOLS = (
+    "analyze_stripe_data",
+)
+
+_RESOLVED = 0.95
+
+# prefix → what the object is. Kept explicit rather than matching a generic
+# `\w+_[A-Za-z0-9]{14,}` because an unknown prefix is far more likely to be
+# someone's own snake_case identifier than a Stripe object.
+_OBJECT_PREFIXES: dict[str, str] = {
+    "ch": "charge",
+    "pi": "payment_intent",
+    "cus": "customer",
+    "sub": "subscription",
+    "in": "invoice",
+    "il": "invoice_item",
+    "price": "price",
+    "prod": "product",
+    "acct": "account",
+    "evt": "event",
+    "re": "refund",
+    "txn": "balance_transaction",
+    "po": "payout",
+    "seti": "setup_intent",
+    "pm": "payment_method",
+    "cs": "checkout_session",
+    "dp": "dispute",
+    "sk": "secret_key",
+    "rk": "restricted_key",
+}
+
+# Stripe ids are prefix + '_' + at least 14 base62 characters, optionally with
+# a `test_` segment in live-vs-test form (`sk_test_…`, `ch_test_…`).
+_OBJECT_ID = re.compile(
+    r"\b(" + "|".join(sorted(_OBJECT_PREFIXES, key=len, reverse=True)) + r")_"
+    r"(?:test_|live_)?([A-Za-z0-9]{14,})\b"
+)
+
+
+class PaymentsPack(BaseDomainPack):
+    """Recognises Stripe object ids and owns the payments workflows."""
+
+    name = PACK_NAME
+
+    def resolve_entities(self, message: str) -> Sequence[EntityMatch]:
+        text = message or ""
+        if "_" not in text:
+            # Every id this pack knows contains an underscore, so this one
+            # check skips the regex entirely for the overwhelming majority of
+            # messages — the resolver runs on every message, for every pack.
+            return ()
+
+        seen: set[str] = set()
+        entities: list[EntityMatch] = []
+        for match in _OBJECT_ID.finditer(text):
+            value = match.group(0)
+            if value in seen:
+                continue
+            seen.add(value)
+            entities.append(EntityMatch(
+                pack=PACK_NAME,
+                kind=_OBJECT_PREFIXES[match.group(1)],
+                value=value,
+                surface=value,
+                position=match.start(),
+                confidence=_RESOLVED,
+            ))
+        return tuple(entities)
+
+    def tool_names(self) -> Sequence[str]:
+        return PAYMENT_TOOLS
+
+    def prompt_fragment(self, activation: PackActivation) -> str:
+        kinds = ", ".join(sorted({e.kind for e in activation.entities}))
+        has_key = any(e.kind.endswith("_key") for e in activation.entities)
+        text = (
+            f"Stripe 对象已识别（{kinds}）。\n"
+            "用工具取回的账务数据回答，不要凭记忆推断金额、状态或结算周期；"
+            "涉及退款、扣款、订阅变更等写操作时，先说明将要发生什么并等待确认。"
+        )
+        if has_key:
+            # The one case where the right move is to stop rather than help.
+            text += (
+                "\n⚠ 消息中疑似包含 Stripe 密钥。不要复述它、不要写入文件、"
+                "不要用它发起请求；提醒用户立即在 Stripe 后台轮换该密钥。"
+            )
+        return text
+
+    def acceptance_commands(self, activation: PackActivation) -> Sequence[str]:
+        # Looked up through the module rather than a name bound at import, so
+        # what this workspace declares is read when the turn runs — a .ariarc
+        # edited mid-session takes effect on the next message, not the next
+        # process.
+        from aria_code.packs import rules
+
+        return rules.acceptance_commands_for(PACK_NAME)
+
+
+PAYMENTS_PACK = PaymentsPack()
+
+
+def register() -> PaymentsPack:
+    """Register the payments pack.  Idempotent."""
+    from aria_code.packs.registry import register_pack
+
+    register_pack(PAYMENTS_PACK)
+    return PAYMENTS_PACK
+
+
+__all__ = [
+    "PACK_NAME",
+    "PAYMENTS_PACK",
+    "PAYMENT_TOOLS",
+    "PaymentsPack",
+    "register",
+]

aria_code/packs/realty/__init__.py

@@ -0,0 +1,190 @@
+"""Real estate — a city's housing market.
+
+This pack is the contract's hard case, and worth reading as one.  Its domain
+has no ``AAPL`` and no ``ch_3Pq…``: the thing a housing question is *about* is
+a city, and a city name on its own is a perfectly ordinary word.  "北京" appears
+in travel plans, in address parsing, in a comment about a datacenter region.
+
+So the entity this pack resolves is not the city.  It is **this city's housing
+market**, which takes two parts to name: a city from a real table, and a
+housing term in the same message.  A city alone resolves at a confidence below
+the activation threshold — reported, so the UI can ask, but never enough to
+answer a code question with a house-price index on its own initiative.
+
+That is the same rule finance applies to a bare uppercase run, arrived at from
+the opposite direction: finance has to *demote* a shape that looks like an
+identifier, and realty has to *combine* two things neither of which is one.
+"""
+
+from __future__ import annotations
+
+from typing import Sequence
+
+from aria_code.packs.base import BaseDomainPack, EntityMatch, PackActivation
+
+PACK_NAME = "realty"
+
+# Empty on purpose. get_house_price_index/get_re_investment exist as functions
+# in realty_data_tools but have no register_* wrapper, so they are not in
+# LOCAL_TOOLS. Naming them here told the model about a capability it does not
+# have, which costs a wasted round and a confusing "unknown tool" error.
+# The pack still contributes its handler and its prompt guidance.
+REALTY_TOOLS: tuple[str, ...] = ()
+
+_RESOLVED = 0.95
+_CITY_ONLY = 0.3
+
+# Terms that name a housing market by themselves, with no city attached.
+# "全国房价走势" is a real question about a real market, and refusing it would
+# lose behaviour the ungated chain used to provide.
+#
+# The line drawn here is narrower than the handler's keyword list on purpose.
+# "房价" and "楼市" name a market; "房产", "地产" and "物业" name a *topic*, and
+# they appear in the source of any property-management codebase — which is
+# exactly the kind of message that must not come back as a price index.
+_NATIONAL_MARKET_TERMS = (
+    "房价", "楼市", "楼价", "二手房", "新房",
+    "house price", "home price", "housing market", "property price",
+)
+
+
+def _tables() -> tuple[tuple[str, ...], tuple[str, ...], tuple[str, ...]]:
+    """City and keyword tables, borrowed rather than duplicated.
+
+    They live in ``market_detect`` because the legacy chain used them; a copy
+    here would drift, and the failure that drift produces (a city Aria stopped
+    recognising after someone edited one list) is silent.
+    """
+    try:
+        from aria_code.apps.cli.utils.market_detect import (
+            _CN_CITIES,
+            _INTL_CITIES,
+            _REALTY_QUERY_KEYWORDS,
+        )
+    except Exception:
+        return (), (), ()
+    return tuple(_CN_CITIES), tuple(_INTL_CITIES), tuple(_REALTY_QUERY_KEYWORDS)
+
+
+class RealtyPack(BaseDomainPack):
+    """Recognises a named city's housing market."""
+
+    name = PACK_NAME
+
+    def resolve_entities(self, message: str) -> Sequence[EntityMatch]:
+        text = message or ""
+        if not text.strip():
+            return ()
+
+        cn_cities, intl_cities, keywords = _tables()
+        if not cn_cities and not intl_cities:
+            return ()
+
+        lowered = text.lower()
+        has_housing_term = any(keyword in lowered for keyword in keywords)
+
+        found: list[tuple[str, int]] = []
+        for city in cn_cities:
+            position = text.find(city)
+            if position >= 0:
+                found.append((city, position))
+        for city in intl_cities:
+            position = lowered.find(city)
+            if position >= 0:
+                found.append((city, position))
+
+        if not found:
+            # No city named, but the message may still name the national
+            # market outright.
+            for term in _NATIONAL_MARKET_TERMS:
+                position = lowered.find(term)
+                if position >= 0:
+                    return (EntityMatch(
+                        pack=PACK_NAME, kind="housing_market", value="全国",
+                        surface=term, position=position, confidence=_RESOLVED,
+                    ),)
+            return ()
+
+        # Earliest mention first, and cap it: a message listing fifteen cities
+        # is a table, not a question about a housing market.
+        found.sort(key=lambda item: item[1])
+        confidence = _RESOLVED if has_housing_term else _CITY_ONLY
+
+        seen: set[str] = set()
+        entities: list[EntityMatch] = []
+        for city, position in found[:6]:
+            if city in seen:
+                continue
+            seen.add(city)
+            entities.append(EntityMatch(
+                pack=PACK_NAME, kind="housing_market", value=city,
+                surface=city, position=position, confidence=confidence,
+            ))
+        return tuple(entities)
+
+    def handlers(self) -> Sequence[object]:
+        """The realty handler, now reachable only when a market is named."""
+        try:
+            from aria_code.apps.cli.handlers.realty_handlers import handle_realty_query
+            from aria_code.apps.cli.utils.market_detect import (
+                _CN_CITIES,
+                _INTL_CITIES,
+                _is_realty_query,
+            )
+        except Exception:
+            return ()
+
+        def _handle(message: str) -> dict:
+            return handle_realty_query(
+                message,
+                is_realty_query=_is_realty_query,
+                cn_cities=_CN_CITIES,
+                intl_cities=_INTL_CITIES,
+            )
+
+        return (_handle,)
+
+    def tool_names(self) -> Sequence[str]:
+        return REALTY_TOOLS
+
+    def prompt_fragment(self, activation: PackActivation) -> str:
+        cities = ", ".join(sorted({e.value for e in activation.entities}))
+        # No tool instruction here: this pack exposes none. The price index is
+        # fetched by the deterministic handler above, so if the model is the one
+        # answering, it has no data source and must say so rather than produce
+        # a plausible number.
+        return (
+            f"房地产市场已识别：{cities}。\n"
+            "你没有房价数据工具。除非上文已给出取回的数据，否则不要给出具体房价、"
+            "涨跌幅或指数值——说明数据不可得，并建议用 /realty 命令获取；"
+            "标注统计口径（新房/二手房、环比/同比）与数据时间；输出不构成投资建议。"
+        )
+
+    def acceptance_commands(self, activation: PackActivation) -> Sequence[str]:
+        # Looked up through the module rather than a name bound at import, so
+        # what this workspace declares is read when the turn runs — a .ariarc
+        # edited mid-session takes effect on the next message, not the next
+        # process.
+        from aria_code.packs import rules
+
+        return rules.acceptance_commands_for(PACK_NAME)
+
+
+REALTY_PACK = RealtyPack()
+
+
+def register() -> RealtyPack:
+    """Register the realty pack.  Idempotent."""
+    from aria_code.packs.registry import register_pack
+
+    register_pack(REALTY_PACK)
+    return REALTY_PACK
+
+
+__all__ = [
+    "PACK_NAME",
+    "REALTY_PACK",
+    "REALTY_TOOLS",
+    "RealtyPack",
+    "register",
+]

aria_code/packs/registry.py

@@ -0,0 +1,202 @@
+"""Domain pack registration and entity-gated activation.
+
+Activation is the whole point of this module.  A pack is switched on for a
+message only when it resolves a concrete entity *from that message*, at or
+above a confidence threshold.  Three consequences follow, each of which fixes a
+failure this codebase actually shipped:
+
+  - **Domain vocabulary cannot activate a pack.**  "根据以上分析和建议开始完善"
+    contains 分析 but names nothing; no pack claims it, so no market handler,
+    no quote, no ticker.
+  - **Conversation history cannot activate a pack.**  Only the user's current
+    message is offered to resolvers.  An assistant reply that mentioned
+    "Cassandra/MongoDB" can no longer donate the ticker MDB to the next turn.
+  - **An inactive pack costs nothing.**  It contributes no handlers, no tools
+    and no prompt text, so adding a clinical or logistics pack does not slow
+    down or perturb a finance user, and vice versa.
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import Iterable, Sequence
+
+from aria_code.packs.base import (
+    DEFAULT_ACTIVATION_THRESHOLD,
+    DomainPack,
+    EntityMatch,
+    PackActivation,
+)
+
+logger = logging.getLogger(__name__)
+
+_REGISTRY: dict[str, DomainPack] = {}
+
+
+def register_pack(pack: DomainPack) -> None:
+    """Register *pack* under its name, replacing any earlier registration."""
+    name = getattr(pack, "name", "")
+    if not name:
+        raise ValueError("a domain pack must declare a non-empty name")
+    if not hasattr(pack, "resolve_entities"):
+        raise TypeError(f"pack {name!r} does not implement resolve_entities()")
+    _REGISTRY[name] = pack
+
+
+def unregister_pack(name: str) -> None:
+    _REGISTRY.pop(name, None)
+
+
+def registered_packs() -> tuple[DomainPack, ...]:
+    return tuple(_REGISTRY.values())
+
+
+def get_pack(name: str) -> DomainPack | None:
+    return _REGISTRY.get(name)
+
+
+def clear_registry() -> None:
+    """Drop every registration (tests)."""
+    _REGISTRY.clear()
+
+
+def _entities_from(pack: DomainPack, message: str) -> list[EntityMatch]:
+    """Ask one pack what it recognises, never letting it break the request.
+
+    A resolver runs on every message; a pack that raises, or that returns
+    something malformed, must degrade to "recognises nothing" rather than take
+    the CLI down with it.
+    """
+    try:
+        found = pack.resolve_entities(message) or ()
+    except Exception:
+        logger.debug("pack %r failed to resolve entities", getattr(pack, "name", "?"),
+                     exc_info=True)
+        return []
+    out: list[EntityMatch] = []
+    for entity in found:
+        if isinstance(entity, EntityMatch):
+            out.append(entity)
+    return out
+
+
+def activate_packs(
+    message: str,
+    *,
+    packs: Iterable[DomainPack] | None = None,
+    threshold: float = DEFAULT_ACTIVATION_THRESHOLD,
+) -> tuple[PackActivation, ...]:
+    """Return the packs that claim *message*, most confident first.
+
+    Only the current user message is considered.  Callers must not pass
+    conversation history here: inheriting an entity across turns is what
+    produced a stock quote in reply to "根据以上分析和建议开始完善".
+    """
+    if not (message or "").strip():
+        return ()
+
+    candidates = tuple(packs) if packs is not None else registered_packs()
+    activations: list[PackActivation] = []
+    for pack in candidates:
+        entities = [
+            e for e in _entities_from(pack, message) if e.confidence >= threshold
+        ]
+        if entities:
+            activations.append(
+                PackActivation(
+                    pack=getattr(pack, "name", ""),
+                    entities=tuple(entities),
+                )
+            )
+    activations.sort(key=lambda a: -a.confidence)
+    return tuple(activations)
+
+
+def active_handlers(activations: Sequence[PackActivation]) -> tuple[object, ...]:
+    """Deterministic handlers contributed by the active packs, in order."""
+    handlers: list[object] = []
+    for activation in activations:
+        pack = get_pack(activation.pack)
+        if pack is None:
+            continue
+        try:
+            handlers.extend(pack.handlers() or ())
+        except Exception:
+            logger.debug("pack %r failed to provide handlers", activation.pack,
+                         exc_info=True)
+    return tuple(handlers)
+
+
+def active_tool_names(activations: Sequence[PackActivation]) -> tuple[str, ...]:
+    """Tool names to expose to the model for this message."""
+    names: list[str] = []
+    for activation in activations:
+        pack = get_pack(activation.pack)
+        if pack is None:
+            continue
+        try:
+            for name in pack.tool_names() or ():
+                if name and name not in names:
+                    names.append(str(name))
+        except Exception:
+            logger.debug("pack %r failed to provide tool names", activation.pack,
+                         exc_info=True)
+    return tuple(names)
+
+
+def active_prompt_fragments(activations: Sequence[PackActivation]) -> tuple[str, ...]:
+    """Domain guidance to append to the system prompt for this message."""
+    fragments: list[str] = []
+    for activation in activations:
+        pack = get_pack(activation.pack)
+        if pack is None:
+            continue
+        try:
+            fragment = pack.prompt_fragment(activation) or ""
+        except Exception:
+            logger.debug("pack %r failed to provide a prompt fragment", activation.pack,
+                         exc_info=True)
+            continue
+        if fragment.strip():
+            fragments.append(fragment.strip())
+    return tuple(fragments)
+
+
+def active_acceptance_commands(activations: Sequence[PackActivation]) -> tuple[str, ...]:
+    """Verification commands contributed by the active packs, deduplicated.
+
+    Order follows activation confidence, so the pack that most clearly owns
+    the message gets its check run first — and the acceptance gate stops at
+    the first red, which makes that ordering the difference between a useful
+    failure and a confusing one.
+    """
+    commands: list[str] = []
+    for activation in activations:
+        pack = get_pack(activation.pack)
+        if pack is None:
+            continue
+        try:
+            found = pack.acceptance_commands(activation) or ()
+        except Exception:
+            logger.debug("pack %r failed to provide acceptance commands", activation.pack,
+                         exc_info=True)
+            continue
+        for command in found:
+            text = str(command or "").strip()
+            if text and text not in commands:
+                commands.append(text)
+    return tuple(commands)
+
+
+__all__ = [
+    "activate_packs",
+    "active_acceptance_commands",
+    "active_handlers",
+    "active_prompt_fragments",
+    "active_tool_names",
+    "clear_registry",
+    "get_pack",
+    "register_pack",
+    "registered_packs",
+    "unregister_pack",
+]

aria_code/packs/rules.py

@@ -0,0 +1,90 @@
+"""Where a pack learns what "correct" means in *this* workspace.
+
+A pack knows the shape of its domain — that a waybill is a waybill, that
+``ch_3P…`` is a Stripe charge.  It cannot know how a particular company checks
+that work on those things was done right: which script reconciles their ledger,
+which job validates their schema, what their build is called.  That knowledge
+belongs to the workspace, not to the pack, and it is the one thing that has to
+come from outside for the closed loop to mean anything in a domain the core
+never learned.
+
+So packs read it from the project's own ``.ariarc``::
+
+    "acceptance": {
+      "default":   ["python3 -m pytest -q"],
+      "logistics": ["python3 scripts/reconcile_waybills.py"],
+      "payments":  ["python3 scripts/verify_stripe_sync.py"]
+    }
+
+``default`` applies to every turn.  A pack-named list applies only when that
+pack resolved a concrete entity from the user's message — the same activation
+rule that governs everything else a pack contributes, so declaring a logistics
+check cannot slow down or perturb a payments question.
+
+This is the whole productisation story for a new industry: a company does not
+extend Aria to adopt it, they declare what green looks like and the loop they
+already have starts holding that line.
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import Sequence
+
+logger = logging.getLogger(__name__)
+
+DEFAULT_KEY = "default"
+
+
+def _coerce(value: object) -> tuple[str, ...]:
+    """Accept a string or a list of them; ignore anything else.
+
+    Hand-edited config is the input here, so a single command written as a
+    bare string is the expected mistake, not an error worth failing a turn
+    over.
+    """
+    if isinstance(value, str):
+        text = value.strip()
+        return (text,) if text else ()
+    if isinstance(value, (list, tuple)):
+        out: list[str] = []
+        for item in value:
+            if isinstance(item, str) and item.strip():
+                out.append(item.strip())
+        return tuple(out)
+    return ()
+
+
+def acceptance_commands_for(pack_name: str, *, rc: object = None) -> tuple[str, ...]:
+    """Commands this workspace declares for *pack_name*.
+
+    Never raises: a malformed or missing ``.ariarc`` means "nothing declared",
+    which falls back to inference from the workspace — the behaviour before
+    any of this existed.
+    """
+    config = rc
+    if config is None:
+        try:
+            from aria_code.ariarc import get_ariarc
+
+            config = get_ariarc()
+        except Exception:
+            logger.debug("could not load .ariarc for acceptance commands", exc_info=True)
+            return ()
+
+    table = getattr(config, "acceptance", None)
+    if not isinstance(table, dict):
+        return ()
+    return _coerce(table.get(pack_name))
+
+
+def default_acceptance_commands(*, rc: object = None) -> tuple[str, ...]:
+    """Commands this workspace declares for every turn, pack or not."""
+    return acceptance_commands_for(DEFAULT_KEY, rc=rc)
+
+
+__all__ = [
+    "DEFAULT_KEY",
+    "acceptance_commands_for",
+    "default_acceptance_commands",
+]