aria-code 0.167.0__py3-none-win_amd64.whl

aria_bots/logistics/mcp_server.py

@@ -0,0 +1,156 @@
+"""The logistics tools as an MCP server, so the Go engine can use them.
+
+    aria-logistics-mcp [--data-dir DIR]
+
+Speaks MCP over stdio (newline-delimited JSON-RPC 2.0). Three read-only
+tools: analyze_logistics_data, score_carriers, plan_inventory_policy.
+
+Shipper scope is not the model's choice. The server reads ARIA_OWNER_SCOPE
+from its own environment (the engine passes it down from the bot that started
+the turn) and every tool goes through logistics.tenancy, which fails closed.
+
+A `file_path` argument is read only from inside the data folder
+(`--data-dir`, else ARIA_LOGISTICS_DATA_DIR). With no data folder, files are
+refused and the tools take inline records only: a chat must not be able to
+name any file on the host.
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import sys
+from pathlib import Path
+from typing import Any, Callable, Dict, Optional, TextIO
+
+from .carriers import SCHEMA as CARRIER_SCHEMA, tool_score_carriers
+from .freight import tool_analyze_logistics_data
+from .inventory import SCHEMA as INVENTORY_SCHEMA, tool_plan_inventory_policy
+from .tenancy import OWNER_SCOPE_ENV, owner_params_schema
+
+PROTOCOL_VERSION = "2024-11-05"
+DATA_DIR_ENV = "ARIA_LOGISTICS_DATA_DIR"
+
+FREIGHT_SCHEMA = {
+    "name": "analyze_logistics_data",
+    "description": "Analyze actual waybills from supplied records, a CSV/JSON file, or an existing local database",
+    "parameters": {
+        "type": "object",
+        "properties": {
+            "file_path": {"type": "string", "description": "CSV or JSON waybill file path"},
+            "waybills": {"type": "array", "description": "Waybill records with total_cost"},
+            **owner_params_schema(),
+        },
+    },
+}
+
+TOOLS: Dict[str, tuple[Callable[[Dict[str, Any]], Dict[str, Any]], Dict[str, Any]]] = {
+    "analyze_logistics_data": (tool_analyze_logistics_data, FREIGHT_SCHEMA),
+    "score_carriers": (tool_score_carriers, CARRIER_SCHEMA),
+    "plan_inventory_policy": (tool_plan_inventory_policy, INVENTORY_SCHEMA),
+}
+
+
+def tool_list() -> list[Dict[str, Any]]:
+    return [
+        {
+            "name": name,
+            "description": schema["description"],
+            "inputSchema": schema.get("parameters") or {"type": "object", "properties": {}},
+            "annotations": {"readOnlyHint": True, "openWorldHint": False},
+        }
+        for name, (_, schema) in TOOLS.items()
+    ]
+
+
+def confine(arguments: Dict[str, Any], data_dir: Optional[Path]) -> Dict[str, Any]:
+    """Resolve file_path inside the data folder, or refuse it."""
+    file_path = arguments.get("file_path")
+    if not file_path:
+        return arguments
+    if data_dir is None:
+        raise ValueError(f"Files are not available here; set {DATA_DIR_ENV} or pass records inline")
+    root = data_dir.resolve()
+    candidate = Path(str(file_path)).expanduser()
+    path = (candidate if candidate.is_absolute() else root / candidate).resolve()
+    if path != root and root not in path.parents:
+        raise ValueError("file_path must be inside the logistics data folder")
+    return {**arguments, "file_path": str(path)}
+
+
+def call_tool(name: str, arguments: Any, data_dir: Optional[Path]) -> Dict[str, Any]:
+    entry = TOOLS.get(name)
+    if entry is None:
+        return {"content": [{"type": "text", "text": f"Unknown tool: {name}"}], "isError": True}
+    if not isinstance(arguments, dict):
+        arguments = {}
+    try:
+        result = entry[0](confine(arguments, data_dir))
+    except ValueError as exc:
+        result = {"success": False, "error": str(exc)}
+    except Exception as exc:  # a tool bug must not take the server down
+        result = {"success": False, "error": f"{type(exc).__name__}: {exc}"}
+    failed = isinstance(result, dict) and result.get("success") is False
+    text = json.dumps(result, ensure_ascii=False, default=str)
+    return {"content": [{"type": "text", "text": text}], "isError": failed}
+
+
+def handle(message: Dict[str, Any], data_dir: Optional[Path]) -> Optional[Dict[str, Any]]:
+    method = message.get("method")
+    if "id" not in message:
+        return None  # a notification
+    reply: Dict[str, Any] = {"jsonrpc": "2.0", "id": message["id"]}
+    params = message.get("params") or {}
+    if method == "initialize":
+        scope = os.environ.get(OWNER_SCOPE_ENV, "").strip()
+        reply["result"] = {
+            "protocolVersion": PROTOCOL_VERSION,
+            "capabilities": {"tools": {}},
+            "serverInfo": {"name": "aria-logistics", "version": "0.1.0"},
+            "instructions": "Logistics analyses scoped to one shipper." if scope else
+            "Logistics analyses; data spanning shippers needs owner_id or all_owners.",
+        }
+    elif method == "ping":
+        reply["result"] = {}
+    elif method == "tools/list":
+        reply["result"] = {"tools": tool_list()}
+    elif method == "tools/call":
+        reply["result"] = call_tool(str(params.get("name", "")), params.get("arguments"), data_dir)
+    else:
+        reply["error"] = {"code": -32601, "message": f"Method not found: {method}"}
+    return reply
+
+
+def serve(stdin: TextIO, stdout: TextIO, data_dir: Optional[Path]) -> None:
+    for line in stdin:
+        line = line.strip()
+        if not line:
+            continue
+        try:
+            message = json.loads(line)
+        except json.JSONDecodeError:
+            reply: Optional[Dict[str, Any]] = {"jsonrpc": "2.0", "id": None,
+                                               "error": {"code": -32700, "message": "Parse error"}}
+        else:
+            reply = handle(message, data_dir) if isinstance(message, dict) else None
+        if reply is not None:
+            stdout.write(json.dumps(reply, ensure_ascii=False) + "\n")
+            stdout.flush()
+
+
+def main(argv: Optional[list[str]] = None) -> int:
+    parser = argparse.ArgumentParser(prog="aria-logistics-mcp", description=__doc__.splitlines()[0])
+    parser.add_argument("--data-dir", default=os.environ.get(DATA_DIR_ENV) or None,
+                        help=f"folder file_path is read from (default ${DATA_DIR_ENV}; none: inline records only)")
+    args = parser.parse_args(argv)
+    data_dir = Path(args.data_dir).expanduser() if args.data_dir else None
+    # MCP is UTF-8 JSON lines. Windows' default (cp1252, CRLF) would crash on
+    # the first non-ASCII description and add \r to every line.
+    for stream in (sys.stdin, sys.stdout):
+        stream.reconfigure(encoding="utf-8", newline="\n")  # type: ignore[union-attr]
+    serve(sys.stdin, sys.stdout, data_dir)
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

aria_bots/logistics/records.py

@@ -0,0 +1,119 @@
+"""Input loading and field validation shared by the logistics analyses.
+
+Every analysis here reports figures a 3PL may bill or negotiate on, so the
+rules are strict: a value that cannot be read is an error naming the row,
+never a silent zero, and an empty input is an error, never a sample dataset.
+"""
+
+from __future__ import annotations
+
+import csv
+import json
+import math
+import pathlib
+from typing import Any
+
+
+def load_records(params: dict[str, Any], key: str) -> tuple[list[dict[str, Any]], str]:
+    """Records from params[key] or a CSV/JSON file, and a label for where they came from."""
+    inline = params.get(key)
+    file_path = params.get("file_path")
+    if inline is not None and file_path:
+        raise ValueError(f"Provide either file_path or {key}, not both")
+    if file_path:
+        path = pathlib.Path(str(file_path)).expanduser().resolve()
+        if not path.is_file():
+            # The OSError read "[Errno 2] No such file or directory:
+            # '/private/var/…/shipments.csv'". Say which files are there.
+            here = sorted(p.name for p in path.parent.glob("*") if p.suffix.lower() in (".csv", ".json"))[:6]
+            hint = f" CSV/JSON files in {path.parent.name or path.parent}: {', '.join(here)}" if here else ""
+            raise ValueError(f"No such file: {file_path}.{hint}")
+        suffix = path.suffix.lower()
+        if suffix == ".json":
+            content = json.loads(path.read_text(encoding="utf-8"))
+            records = content.get(key) if isinstance(content, dict) else content
+        elif suffix == ".csv":
+            with path.open(encoding="utf-8-sig", newline="") as handle:
+                records = list(csv.DictReader(handle))
+        else:
+            raise ValueError("Only CSV and JSON files are supported")
+        source = f"file:{path.name}"
+    else:
+        records = inline
+        source = "caller-supplied records"
+    if not isinstance(records, list) or not records:
+        raise ValueError(f"No {key} records supplied")
+    for row, record in enumerate(records, 1):
+        if not isinstance(record, dict):
+            raise ValueError(f"Row {row}: each record must be an object")
+    return records, source
+
+
+def number(record: dict[str, Any], field: str, row: int, *, required: bool = False,
+           positive: bool = False) -> float | None:
+    """A finite, non-negative number, or None when absent and optional."""
+    value = record.get(field)
+    if value is None or (isinstance(value, str) and not value.strip()):
+        if required:
+            raise ValueError(f"Row {row}: {field} is required")
+        return None
+    if isinstance(value, bool):
+        raise ValueError(f"Row {row}: {field} must be a number")
+    try:
+        result = float(value)
+    except (TypeError, ValueError) as exc:
+        raise ValueError(f"Row {row}: {field} must be a number") from exc
+    if not math.isfinite(result) or result < 0:
+        raise ValueError(f"Row {row}: {field} must be finite and non-negative")
+    if positive and result == 0:
+        raise ValueError(f"Row {row}: {field} must be greater than zero")
+    return result
+
+
+def flag(record: dict[str, Any], field: str, row: int) -> bool | None:
+    """A yes/no field, accepting the spellings spreadsheets produce."""
+    value = record.get(field)
+    if value is None or (isinstance(value, str) and not value.strip()):
+        return None
+    if isinstance(value, bool):
+        return value
+    if value in (0, 1):
+        return bool(value)
+    if isinstance(value, str):
+        normalized = value.strip().lower()
+        if normalized in {"true", "yes", "y", "1", "是"}:
+            return True
+        if normalized in {"false", "no", "n", "0", "否"}:
+            return False
+    raise ValueError(f"Row {row}: {field} must be true/false")
+
+
+def series(record: dict[str, Any], field: str, row: int) -> list[float] | None:
+    """A list of non-negative numbers, from a JSON array or a CSV cell like "3;5;2"."""
+    value = record.get(field)
+    if value is None or (isinstance(value, str) and not value.strip()):
+        return None
+    if isinstance(value, str):
+        parts = [p for p in value.replace(",", ";").replace(" ", ";").split(";") if p]
+    elif isinstance(value, list):
+        parts = value
+    else:
+        raise ValueError(f"Row {row}: {field} must be a list of numbers")
+    out: list[float] = []
+    for index, part in enumerate(parts, 1):
+        try:
+            item = float(part)
+        except (TypeError, ValueError) as exc:
+            raise ValueError(f"Row {row}: {field} item {index} must be a number") from exc
+        if not math.isfinite(item) or item < 0:
+            raise ValueError(f"Row {row}: {field} item {index} must be finite and non-negative")
+        out.append(item)
+    return out
+
+
+def text(record: dict[str, Any], field: str, row: int, *, required: bool = False) -> str:
+    value = record.get(field)
+    result = "" if value is None else str(value).strip()
+    if required and not result:
+        raise ValueError(f"Row {row}: {field} is required")
+    return result

aria_bots/logistics/tenancy.py

@@ -0,0 +1,152 @@
+"""Shipper (货主) isolation for third-party-logistics analyses.
+
+A 3PL holds many shippers' inventory and waybills side by side. An analysis
+that sums them — an average cost per kg, a carrier ranking, a reorder list —
+is computed from one client's commercial data and handed to another. That is
+a data leak whether or not anyone notices, so the analyses do not decide it
+case by case: every one of them goes through `scope_records` first, and it
+fails closed.
+
+  - Records that carry no owner_id at all are single-tenant data, and pass.
+  - Records that all belong to one shipper pass.
+  - Records that span shippers are refused unless the caller names one
+    (`owner_id`, a client-facing analysis) or explicitly asks for the 3PL's
+    internal cross-shipper view (`all_owners=True`), which is marked as not
+    for client distribution.
+  - A mix of records with and without owner_id is refused, because there is
+    no safe way to attribute the unlabelled ones.
+
+What an error message says is part of the guarantee: it may say how many
+shippers the data spans, but never which, so a refusal does not itself
+disclose another client's name.
+
+Conversation scope
+------------------
+A chat bound to one shipper (a 3PL usually keeps one group per client) sets
+ARIA_OWNER_SCOPE for every turn it runs. Then, whatever the model asks for:
+  - owner_id defaults to that shipper, and naming another is refused;
+  - all_owners is refused — the internal view has no place in a client chat;
+  - records without owner_id are refused, because nothing shows they are this
+    shipper's (a file on the host could be anyone's).
+This is enforced here rather than in a prompt, so it holds for the CLI, the
+MCP server and every chat channel alike, and does not depend on the model
+choosing to comply.
+"""
+
+from __future__ import annotations
+
+import os
+from typing import Any, Iterable
+
+OWNER_FIELD = "owner_id"
+OWNER_SCOPE_ENV = "ARIA_OWNER_SCOPE"
+
+INTERNAL_MARKER = "INTERNAL — cross-shipper view; not for client distribution"
+
+
+class TenancyError(ValueError):
+    """The records cannot be analysed without mixing shippers."""
+
+
+def active_owner_scope() -> str:
+    """The shipper this process is confined to, or "" when unconfined."""
+    return os.environ.get(OWNER_SCOPE_ENV, "").strip()
+
+
+def _owner_of(record: dict[str, Any]) -> str:
+    value = record.get(OWNER_FIELD)
+    return "" if value is None else str(value).strip()
+
+
+def scope_records(
+    records: Iterable[dict[str, Any]],
+    owner_id: str | None = None,
+    *,
+    all_owners: bool = False,
+) -> tuple[list[dict[str, Any]], dict[str, Any]]:
+    """Return the records an analysis may use, and a description of the scope.
+
+    The scope dict is copied into every result, so a reader can always tell
+    whose data a number came from and whether it may be shown to a client.
+    """
+    records = list(records)
+    wanted = (owner_id or "").strip()
+    if wanted and all_owners:
+        raise TenancyError("Pass owner_id or all_owners, not both")
+
+    scope = active_owner_scope()
+    if scope:
+        if all_owners:
+            raise TenancyError(
+                "This conversation is confined to one shipper; the cross-shipper view "
+                "is not available here"
+            )
+        if wanted and wanted != scope:
+            raise TenancyError("This conversation is confined to one shipper and cannot analyse another")
+        wanted = scope
+
+    labelled = [r for r in records if _owner_of(r)]
+    unlabelled = len(records) - len(labelled)
+
+    if not labelled:
+        if scope:
+            raise TenancyError(
+                f"This conversation is confined to one shipper, so every record must carry "
+                f"{OWNER_FIELD} to show it is theirs; these records have none"
+            )
+        if wanted:
+            raise TenancyError(
+                f"owner_id {wanted!r} was requested, but the records carry no {OWNER_FIELD}"
+            )
+        return records, {"mode": "single_tenant", "client_facing": True}
+
+    if unlabelled:
+        raise TenancyError(
+            f"{unlabelled} of {len(records)} records have no {OWNER_FIELD}; they cannot "
+            f"be attributed to a shipper, so they cannot be analysed alongside records "
+            f"that can"
+        )
+
+    owners = {_owner_of(r) for r in labelled}
+
+    if wanted:
+        in_scope = [r for r in labelled if _owner_of(r) == wanted]
+        if not in_scope:
+            # Deliberately does not list the owners that *are* present.
+            raise TenancyError(f"No records for owner_id {wanted!r}")
+        result_scope = {"mode": "single_owner", "owner_id": wanted, "client_facing": True}
+        if scope:
+            result_scope["conversation_scoped"] = True
+        return in_scope, result_scope
+
+    if len(owners) == 1:
+        (only,) = owners
+        return labelled, {"mode": "single_owner", "owner_id": only, "client_facing": True}
+
+    if all_owners:
+        return labelled, {
+            "mode": "all_owners",
+            "shipper_count": len(owners),
+            "client_facing": False,
+            "marker": INTERNAL_MARKER,
+        }
+
+    raise TenancyError(
+        f"These records belong to {len(owners)} different shippers. Pass owner_id to "
+        f"analyse one shipper (safe to share with that client), or all_owners=true for "
+        f"the internal cross-shipper view (not for client distribution)."
+    )
+
+
+def owner_params_schema() -> dict[str, Any]:
+    """JSON-schema properties every tenant-aware tool accepts."""
+    return {
+        "owner_id": {
+            "type": "string",
+            "description": "Shipper (货主) to analyse. Required when records span several shippers.",
+        },
+        "all_owners": {
+            "type": "boolean",
+            "description": "Internal 3PL view across all shippers. Output is marked not for client distribution.",
+        },
+    }

aria_bots/market.py

@@ -0,0 +1,91 @@
+"""Market commands for the bots, answered by `aria-runtime daemon`.
+
+The bots used to import the Python daemon's internals (its database path,
+price fetcher and brief builders). Now they run the Go daemon's commands:
+
+    aria-runtime daemon quote SYMBOL --json
+    aria-runtime daemon once morning-brief --json
+    aria-runtime daemon alert add SYMBOL CONDITION VALUE
+    aria-runtime daemon alert list
+    aria-runtime daemon status
+
+Quotes come from financial-service; alerts land in the same daemon.db the
+running daemon watches (ARIA_DAEMON_DIR, else ~/.aria).
+"""
+from __future__ import annotations
+
+import asyncio
+import json
+from typing import Optional
+
+from . import engine
+
+CONDITIONS = ("pct_change_above", "pct_change_below", "price_above", "price_below")
+
+
+class MarketError(RuntimeError):
+    """The daemon command failed; the message is safe to show in a chat."""
+
+
+async def daemon(*args: str, timeout: float = 60) -> str:
+    runtime = engine.find_engine()
+    if not runtime:
+        raise MarketError("未找到 aria-runtime：请安装，或用 ARIA_RUNTIME 指向它。")
+    proc = await asyncio.create_subprocess_exec(
+        runtime, "daemon", *args,
+        stdin=asyncio.subprocess.DEVNULL,
+        stdout=asyncio.subprocess.PIPE,
+        stderr=asyncio.subprocess.PIPE,
+    )
+    try:
+        stdout, stderr = await asyncio.wait_for(proc.communicate(), timeout=timeout)
+    except asyncio.TimeoutError:
+        proc.kill()
+        await proc.wait()
+        raise MarketError(f"aria-runtime daemon {args[0]} 超时（>{int(timeout)}s）") from None
+    if proc.returncode != 0:
+        detail = stderr.decode("utf-8", errors="replace").strip()[-300:] or f"exit {proc.returncode}"
+        raise MarketError(detail)
+    return stdout.decode("utf-8", errors="replace").strip()
+
+
+async def quote(symbol: str) -> dict:
+    """{symbol, price, currency, source[, change_pct]}."""
+    return json.loads(await daemon("quote", symbol, "--json"))
+
+
+async def brief(command: str = "morning-brief") -> tuple[str, str]:
+    """(title, body) of a brief: morning-brief, evening-brief or weekly-recap."""
+    data = json.loads(await daemon("once", command, "--json", timeout=120))
+    return data["title"], data["body"]
+
+
+async def add_alert(symbol: str, condition: str, value: str) -> str:
+    if condition not in CONDITIONS:
+        raise MarketError("条件必须是 " + " / ".join(CONDITIONS))
+    return await daemon("alert", "add", symbol, condition, value)
+
+
+async def list_alerts() -> str:
+    return await daemon("alert", "list")
+
+
+async def status() -> str:
+    return await daemon("status")
+
+
+def price_card(data: dict) -> tuple[str, str, str]:
+    """(title, body, color) for a quote card. Red is up, as in Chinese markets."""
+    symbol, price = data["symbol"], float(data["price"])
+    mark = {"CNY": "¥", "RMB": "¥", "USD": "$", "HKD": "HK$"}.get(str(data.get("currency") or "").upper(), "")
+    change: Optional[float] = data.get("change_pct")
+    lines = [f"**当前价** {mark}{price:,.3f}"]
+    if change is None:
+        color, arrow = "blue", "📈"
+    else:
+        lines.append(f"**涨跌幅** {change:+.2f}%")
+        color = "red" if change > 0 else "green" if change < 0 else "blue"
+        arrow = "📈" if change >= 0 else "📉"
+    if data.get("source"):
+        lines.append(f"**来源** {data['source']}")
+    return f"{arrow} {symbol}", "\n".join(lines), color