shopping-cli 3.2.4__tar.gz → 3.2.5__tar.gz

{shopping_cli-3.2.4/shopping_cli.egg-info → shopping_cli-3.2.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: shopping-cli
-Version: 3.2.4
+Version: 3.2.5
 Summary: Standalone local-commerce AI consultation marketplace runtime
 License:                                  Apache License
                                    Version 2.0, January 2004

{shopping_cli-3.2.4 → shopping_cli-3.2.5}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "shopping-cli"
-version = "3.2.4"
+version = "3.2.5"
 description = "Standalone local-commerce AI consultation marketplace runtime"
 readme = "README.md"
 requires-python = ">=3.11"

{shopping_cli-3.2.4 → shopping_cli-3.2.5}/shopping_cli/__init__.py

@@ -1,3 +1,3 @@
 """Standalone shopping-cli consultation runtime."""
 
-VERSION = "3.2.4"
+VERSION = "3.2.5"

{shopping_cli-3.2.4 → shopping_cli-3.2.5}/shopping_cli/agents/merchant_agent.py

@@ -115,6 +115,29 @@ def _authorized_bargain_amount(product: dict[str, Any]) -> str:
     return ""
 
 
+def _effective_floor_price(product: dict[str, Any]) -> float | None:
+    """解析商家授权的最低成交价（v26 结构化优先）。
+
+    优先级：``product.floor_price > 0`` → 用它；否则
+    ``0 < max_discount_percent <= 100`` → ``price * (1 - discount/100)``；
+    否则回退 ``_authorized_bargain_amount`` 自由文本正则（存量
+    ``automation_boundaries`` 兼容）。全无 → None（无授权底价）。
+    """
+    floor = _safe_non_negative_float(product.get("floor_price"))
+    if floor > 0:
+        return floor
+    discount = _safe_non_negative_float(product.get("max_discount_percent"))
+    if 0 < discount <= 100:
+        return _safe_non_negative_float(product.get("price")) * (1 - discount / 100)
+    free_text = _authorized_bargain_amount(product)
+    if free_text:
+        try:
+            return float(free_text)
+        except (TypeError, ValueError):
+            return None
+    return None
+
+
 def generate_reply(
     tools: MerchantAgentTools,
     conversation: dict[str, Any],

{shopping_cli-3.2.4 → shopping_cli-3.2.5}/shopping_cli/api/handlers/catalog.py

@@ -320,6 +320,9 @@ def create_product(
             description=str(payload.get("description") or ""),
             delivery_attributes=payload.get("delivery_attributes") or [],
             handoff_destination=str(payload.get("handoff_destination") or ""),
+            floor_price=payload.get("floor_price", 0.0),
+            max_discount_percent=payload.get("max_discount_percent", 0.0),
+            promotions=payload.get("promotions"),
         )
         return {"ok": True, "product": product}
 
@@ -349,6 +352,9 @@ def update_product(
             handoff_destination=payload.get("handoff_destination")
             if "handoff_destination" in payload
             else None,
+            floor_price=payload.get("floor_price"),
+            max_discount_percent=payload.get("max_discount_percent"),
+            promotions=payload.get("promotions") if "promotions" in payload else None,
         )
         return {"ok": True, "product": product}
 

{shopping_cli-3.2.4 → shopping_cli-3.2.5}/shopping_cli/api/handlers/listings_projection.py

@@ -62,7 +62,14 @@ def get_listing_projection(db_path: str | Path, sku: str, payload: dict[str, Any
         )
         try:
             # 审查 S-M3：私有剥离收进投影层（include_private）。
-            projection = project_product_listing(conn, sku, include_private=is_owner)
+            # merchant_id 由商品 owner 派生（配送时效是商家级字段，投影需要它）；
+            # 此前缺省 "" 会让商家级 delivery_times 在该路径静默丢失。
+            projection = project_product_listing(
+                conn,
+                sku,
+                merchant_id=str(row["merchant_id"] or "") if row is not None else "",
+                include_private=is_owner,
+            )
         except ProjectionError as exc:
             raise NotFoundError(str(exc)) from exc
         return {"ok": True, "projection": projection}

{shopping_cli-3.2.4 → shopping_cli-3.2.5}/shopping_cli/cli.py

@@ -33,7 +33,10 @@ from shopping_cli.cli_agent_commands import (
     cmd_agent_tokens,
 )
 from shopping_cli.cli_catalog_commands import (
+    cmd_delivery_remove_time,
     cmd_delivery_set,
+    cmd_delivery_set_time,
+    cmd_delivery_times,
     cmd_merchant_create,
     cmd_merchant_list,
     cmd_merchant_update,
@@ -511,6 +514,25 @@ def build_parser() -> argparse.ArgumentParser:
     delivery_set.add_argument("--format", choices=["text", "json"], default="text")
     delivery_set.set_defaults(func=cmd_delivery_set)
 
+    delivery_set_time = delivery_sub.add_parser("set-time", help="Set delivery time for one region (days)")
+    delivery_set_time.add_argument("--merchant", required=True)
+    delivery_set_time.add_argument("--region", required=True, help="区域名，如 东北 / 华北")
+    delivery_set_time.add_argument("--min-days", type=positive_int, required=True)
+    delivery_set_time.add_argument("--max-days", type=positive_int, required=True)
+    delivery_set_time.add_argument("--format", choices=["text", "json"], default="text")
+    delivery_set_time.set_defaults(func=cmd_delivery_set_time)
+
+    delivery_remove_time = delivery_sub.add_parser("remove-time", help="Remove delivery time for one region")
+    delivery_remove_time.add_argument("--merchant", required=True)
+    delivery_remove_time.add_argument("--region", required=True)
+    delivery_remove_time.add_argument("--format", choices=["text", "json"], default="text")
+    delivery_remove_time.set_defaults(func=cmd_delivery_remove_time)
+
+    delivery_times = delivery_sub.add_parser("times", help="Show per-region delivery times")
+    delivery_times.add_argument("--merchant", required=True)
+    delivery_times.add_argument("--format", choices=["text", "json"], default="text")
+    delivery_times.set_defaults(func=cmd_delivery_times)
+
     product = subparsers.add_parser("product", help="Manage products and stock")
     product_sub = product.add_subparsers(dest="product_command", required=True)
     product_add = product_sub.add_parser("add", help="Publish a product")

{shopping_cli-3.2.4 → shopping_cli-3.2.5}/shopping_cli/cli_catalog_commands.py

@@ -9,9 +9,13 @@ from shopping_cli.cli_common import db_path_from_args, emit
 from shopping_cli.core.catalog import (
     create_merchant,
     create_product,
+    delivery_rule,
     list_merchants,
+    remove_delivery_time,
+    render_delivery_times_hint,
     search_merchants,
     search_products,
+    set_delivery_time,
     set_stock,
     update_merchant,
     update_product,
@@ -112,6 +116,41 @@ def emit_delivery_rule_text(merchant_id: str, delivery: dict[str, Any]) -> None:
     print(f"ETA: {int(delivery.get('eta_minutes') or 0)} minutes")
     print(f"Radius: {float(delivery.get('radius_km') or 0):g} km")
     print(f"Notes: {delivery.get('notes') or '-'}")
+    print(f"Delivery times: {render_delivery_times_hint(delivery.get('delivery_times'))}")
+
+
+def cmd_delivery_set_time(args: argparse.Namespace) -> None:
+    with db_session(db_path_from_args(args)) as conn:
+        delivery = set_delivery_time(
+            conn,
+            args.merchant,
+            region=args.region,
+            min_days=args.min_days,
+            max_days=args.max_days,
+        )
+    if args.format == "text":
+        print(f"Delivery time set: {args.merchant} {render_delivery_times_hint(delivery.get('delivery_times'))}")
+        return
+    emit({"ok": True, "merchant_id": args.merchant, "delivery": delivery}, args.format)
+
+
+def cmd_delivery_remove_time(args: argparse.Namespace) -> None:
+    with db_session(db_path_from_args(args)) as conn:
+        delivery = remove_delivery_time(conn, args.merchant, region=args.region)
+    if args.format == "text":
+        print(f"Delivery time removed: {args.merchant} {render_delivery_times_hint(delivery.get('delivery_times'))}")
+        return
+    emit({"ok": True, "merchant_id": args.merchant, "delivery": delivery}, args.format)
+
+
+def cmd_delivery_times(args: argparse.Namespace) -> None:
+    with db_session(db_path_from_args(args)) as conn:
+        delivery = delivery_rule(conn, args.merchant)
+    if args.format == "text":
+        print(f"Delivery times: {args.merchant}")
+        print(render_delivery_times_hint(delivery.get("delivery_times")))
+        return
+    emit({"ok": True, "merchant_id": args.merchant, "delivery_times": delivery.get("delivery_times", {})}, args.format)
 
 
 def cmd_product_add(args: argparse.Namespace) -> None:

{shopping_cli-3.2.4 → shopping_cli-3.2.5}/shopping_cli/core/catalog.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import json
 import math
 import re
 import sqlite3
@@ -45,6 +46,51 @@ def parse_tags(value: str | list[str] | None) -> list[str]:
     return bounded_string_list([part.strip() for part in parts if part.strip()], "tags")
 
 
+def parse_promotions(value: list | None) -> list[dict[str, Any]]:
+    """促销数组轻校验（v26）：list of dict，每项含非空 title。返回可 JSON 编码 list。
+
+    促销为商家私有元数据，本里程碑只做形态校验 + 存取，不参与谈判门判断。
+    """
+    if value is None:
+        return []
+    if not isinstance(value, list):
+        raise ValidationError("promotions must be a list")
+    result: list[dict[str, Any]] = []
+    for item in value:
+        if not isinstance(item, dict):
+            raise ValidationError("each promotion must be an object")
+        title = str(item.get("title") or "").strip()
+        if not title:
+            raise ValidationError("each promotion must have a non-empty title")
+        result.append(item)
+    return result
+
+
+def decode_promotions(value: str | None) -> list[dict[str, Any]]:
+    """解码 promotions_json：list of dict（区别于 ``decode_json`` 的字符串列表归一化）。
+
+    ``decode_json(value, [])`` 会把 list 归一化为 list[str] 并丢弃 dict 项，
+    不适合促销数组（元素为 dict）；本函数按 list-of-dict 解码，非法/空值回退 []。
+    """
+    if not value:
+        return []
+    try:
+        decoded = json.loads(value)
+    except (TypeError, ValueError):
+        return []
+    if not isinstance(decoded, list):
+        return []
+    return [item for item in decoded if isinstance(item, dict)]
+
+
+def _discount_percent(value: Any, message: str) -> float:
+    """最大折扣率校验：finite + 0 <= x <= 100（0=无折扣授权）。"""
+    percent = _finite_float(value, message)
+    if percent < 0 or percent > 100:
+        raise ValidationError(f"{message} (must be between 0 and 100)")
+    return percent
+
+
 def require_merchant(conn: sqlite3.Connection, merchant_id: str) -> sqlite3.Row:
     row = conn.execute("select * from merchants where id = ?", (merchant_id,)).fetchone()
     if row is None:
@@ -330,6 +376,145 @@ def upsert_delivery_rule(
     return delivery_rule(conn, merchant_id)
 
 
+# 配送时效天数上限（区域时效为天数区间，封顶防止脏数据进入发现投影）。
+MAX_DELIVERY_DAYS = 365
+
+
+def decode_delivery_times(value: str | None) -> dict[str, dict[str, int]]:
+    """解码 delivery_times_json：区域 → {min_days, max_days}。
+
+    仿 ``decode_promotions``（list-of-dict）按 dict-of-dict 校验：非 dict /
+    损坏 / 条目缺 min_days/max_days 或非正整数 → 丢弃该条，整体非法回退 {}。
+    不抛异常（数据面读取容错），写入侧由 ``set_delivery_time`` 强校验。
+    """
+    if not value:
+        return {}
+    try:
+        decoded = json.loads(value)
+    except (TypeError, ValueError):
+        return {}
+    if not isinstance(decoded, dict):
+        return {}
+    result: dict[str, dict[str, int]] = {}
+    for region, entry in decoded.items():
+        if not isinstance(region, str) or not region.strip():
+            continue
+        if not isinstance(entry, dict):
+            continue
+        try:
+            min_days = int(entry.get("min_days"))
+            max_days = int(entry.get("max_days"))
+        except (TypeError, ValueError):
+            continue
+        if min_days < 1 or max_days < min_days or max_days > MAX_DELIVERY_DAYS:
+            continue
+        result[region.strip()] = {"min_days": min_days, "max_days": max_days}
+    return result
+
+
+def set_delivery_time(
+    conn: sqlite3.Connection,
+    merchant_id: str,
+    region: str,
+    min_days: int,
+    max_days: int,
+) -> dict[str, Any]:
+    """维护商家某一区域的配送时效（upsert 单个区域，不影响其它区域）。
+
+    region → {min_days, max_days} 写回 delivery_rules.delivery_times_json。
+    行不存在则插入（其余配送列保持默认），存在则只更新该 JSON + updated_at
+    —— 不触碰 service_area/fee/eta_minutes/radius_km/notes。
+    """
+    region = bounded_text(region, "delivery region", MAX_SHORT_TEXT_CHARS).strip()
+    if not region:
+        raise ValidationError("delivery region must not be empty")
+    min_days = _whole_int(min_days, "delivery min days must be a whole number")
+    max_days = _whole_int(max_days, "delivery max days must be a whole number")
+    if min_days < 1:
+        raise ValidationError("delivery min days must be at least 1")
+    if max_days < min_days:
+        raise ValidationError("delivery max days must be >= min days")
+    if max_days > MAX_DELIVERY_DAYS:
+        raise ValidationError(f"delivery max days must be <= {MAX_DELIVERY_DAYS}")
+    require_merchant(conn, merchant_id)
+    times = delivery_times(conn, merchant_id)
+    times[region] = {"min_days": min_days, "max_days": max_days}
+    now = now_iso()
+    conn.execute(
+        """
+        insert into delivery_rules(merchant_id, delivery_times_json, created_at, updated_at)
+        values (?, ?, ?, ?)
+        on conflict(merchant_id) do update set
+            delivery_times_json = excluded.delivery_times_json,
+            updated_at = excluded.updated_at
+        """,
+        (merchant_id, encode_json(times), now, now),
+    )
+    _audit_catalog(
+        conn,
+        merchant_id,
+        "delivery_time_updated",
+        {"merchant_id": merchant_id, "region": region, "min_days": min_days, "max_days": max_days},
+    )
+    return delivery_rule(conn, merchant_id)
+
+
+def remove_delivery_time(conn: sqlite3.Connection, merchant_id: str, region: str) -> dict[str, Any]:
+    """删除商家某一区域的配送时效（不存在则原样返回，幂等）。"""
+    region = bounded_text(region, "delivery region", MAX_SHORT_TEXT_CHARS).strip()
+    require_merchant(conn, merchant_id)
+    times = delivery_times(conn, merchant_id)
+    if region not in times:
+        return delivery_rule(conn, merchant_id)
+    del times[region]
+    now = now_iso()
+    conn.execute(
+        "update delivery_rules set delivery_times_json = ?, updated_at = ? where merchant_id = ?",
+        (encode_json(times), now, merchant_id),
+    )
+    _audit_catalog(
+        conn,
+        merchant_id,
+        "delivery_time_removed",
+        {"merchant_id": merchant_id, "region": region},
+    )
+    return delivery_rule(conn, merchant_id)
+
+
+def delivery_times(conn: sqlite3.Connection, merchant_id: str) -> dict[str, dict[str, int]]:
+    """读商家配送时效映射（只读、容错；空 → {}）。"""
+    row = conn.execute(
+        "select delivery_times_json from delivery_rules where merchant_id = ?", (merchant_id,)
+    ).fetchone()
+    return decode_delivery_times(row["delivery_times_json"] if row is not None else None)
+
+
+def render_delivery_times_hint(delivery_times_map: Mapping[str, Any] | None) -> str:
+    """区域时效摘要（发现投影 lead_time_hint / CLI 展示），单一来源。
+
+    例：`{"东北": {"min_days": 3, "max_days": 4}, "华北": {"min_days": 1, "max_days": 2}}`
+    → `东北 3-4天；华北 1-2天`；min==max 渲染 `东北 3天`；空 → `-`。
+    """
+    if not delivery_times_map:
+        return "-"
+    parts: list[str] = []
+    for region, entry in delivery_times_map.items():
+        if not isinstance(entry, dict):
+            continue
+        try:
+            min_days = int(entry.get("min_days") or 0)
+            max_days = int(entry.get("max_days") or 0)
+        except (TypeError, ValueError):
+            continue
+        if min_days < 1:
+            continue
+        if min_days == max_days:
+            parts.append(f"{region} {min_days}天")
+        else:
+            parts.append(f"{region} {min_days}-{max_days}天")
+    return "；".join(parts) if parts else "-"
+
+
 def create_product(
     conn: sqlite3.Connection,
     merchant_id: str,
@@ -343,6 +528,9 @@ def create_product(
     description: str = "",
     delivery_attributes: str | list[str] | None = None,
     handoff_destination: str = "",
+    floor_price: float = 0.0,
+    max_discount_percent: float = 0.0,
+    promotions: list | None = None,
 ) -> dict[str, Any]:
     merchant_id = bounded_text(merchant_id, "merchant id", MAX_SHORT_TEXT_CHARS).strip()
     sku = bounded_text(sku, "product sku", MAX_SHORT_TEXT_CHARS).strip()
@@ -362,6 +550,9 @@ def create_product(
     stock = _whole_int(stock, "--stock must be a whole number")
     if stock < 0:
         raise ValidationError("--stock must be non-negative")
+    floor_price = _price_with_precision(floor_price, "--floor-price must be finite and non-negative")
+    max_discount_percent = _discount_percent(max_discount_percent, "--max-discount-percent")
+    promotions = parse_promotions(promotions)
     require_merchant(conn, merchant_id)
     now = now_iso()
     try:
@@ -370,9 +561,10 @@ def create_product(
         insert into products(
             sku, merchant_id, title, description, category, tags_json, price,
             currency, stock, delivery_attributes_json, handoff_destination,
+            floor_price, max_discount_percent, promotions_json,
             active, created_at, updated_at
         )
-        values (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 1, ?, ?)
+        values (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 1, ?, ?)
             """,
             (
             sku,
@@ -386,6 +578,9 @@ def create_product(
             stock,
             encode_json(parse_tags(delivery_attributes)),
             handoff_destination,
+            floor_price,
+            max_discount_percent,
+            encode_json(promotions),
             now,
             now,
             ),
@@ -410,6 +605,9 @@ def update_product(
     description: str | None = None,
     delivery_attributes: str | list[str] | None = None,
     handoff_destination: str | None = None,
+    floor_price: float | None = None,
+    max_discount_percent: float | None = None,
+    promotions: list | None = None,
 ) -> dict[str, Any]:
     product = require_product(conn, sku)
     if merchant_id and product["merchant_id"] != merchant_id:
@@ -435,6 +633,12 @@ def update_product(
         stock = _whole_int(stock, "--stock must be a whole number")
     if stock is not None and stock < 0:
         raise ValidationError("--stock must be non-negative")
+    if floor_price is not None:
+        floor_price = _price_with_precision(floor_price, "--floor-price must be finite and non-negative")
+    if max_discount_percent is not None:
+        max_discount_percent = _discount_percent(max_discount_percent, "--max-discount-percent")
+    if promotions is not None:
+        promotions = parse_promotions(promotions)
     updates: list[str] = []
     values: list[Any] = []
     field_map = {
@@ -444,6 +648,8 @@ def update_product(
         "currency": currency,
         "category": category,
         "description": description,
+        "floor_price": floor_price,
+        "max_discount_percent": max_discount_percent,
     }
     for column, value in field_map.items():
         if value is not None:
@@ -455,6 +661,9 @@ def update_product(
     if delivery_attributes is not None:
         updates.append("delivery_attributes_json = ?")
         values.append(encode_json(parse_tags(delivery_attributes)))
+    if promotions is not None:
+        updates.append("promotions_json = ?")
+        values.append(encode_json(promotions))
     if handoff_destination is not None:
         updates.append("handoff_destination = ?")
         values.append(handoff_destination)
@@ -499,6 +708,7 @@ def delivery_rule(conn: sqlite3.Connection, merchant_id: str) -> dict[str, Any]:
             "eta_minutes": 0,
             "radius_km": 0.0,
             "notes": "",
+            "delivery_times": {},
         }
     return {
         "service_area": row["service_area"],
@@ -507,6 +717,7 @@ def delivery_rule(conn: sqlite3.Connection, merchant_id: str) -> dict[str, Any]:
         "eta_minutes": _safe_non_negative_int(row["eta_minutes"]),
         "radius_km": _safe_non_negative_float(row["radius_km"]),
         "notes": row["notes"],
+        "delivery_times": decode_delivery_times(row["delivery_times_json"]),
     }
 
 
@@ -538,6 +749,7 @@ def _delivery_rule_from_joined_merchant(row: sqlite3.Row) -> dict[str, Any]:
         "eta_minutes": _safe_non_negative_int(row["delivery_eta_minutes"]),
         "radius_km": _safe_non_negative_float(row["delivery_radius_km"]),
         "notes": row["delivery_notes"] or "",
+        "delivery_times": decode_delivery_times(row["delivery_times_json"]),
     }
 
 
@@ -568,6 +780,7 @@ def list_merchants(conn: sqlite3.Connection, limit: int = 50, offset: int = 0) -
                dr.eta_minutes as delivery_eta_minutes,
                dr.radius_km as delivery_radius_km,
                dr.notes as delivery_notes,
+               dr.delivery_times_json as delivery_times_json,
                count(p.sku) as active_product_count
         from merchants m
         left join delivery_rules dr on dr.merchant_id = m.id
@@ -596,6 +809,9 @@ def product_summary(conn: sqlite3.Connection, sku: str) -> dict[str, Any]:
         "stock": _safe_non_negative_int(product["stock"]),
         "delivery_attributes": decode_json(product["delivery_attributes_json"], []),
         "handoff_destination": product["handoff_destination"] or "",
+        "floor_price": _safe_non_negative_float(product["floor_price"]),
+        "max_discount_percent": _safe_non_negative_float(product["max_discount_percent"]),
+        "promotions": decode_promotions(product["promotions_json"]),
         "merchant": merchant,
         "delivery": merchant["delivery"],
         "warnings": product_warnings(product, merchant),
@@ -631,6 +847,9 @@ def _product_summary_from_search_row(row: sqlite3.Row) -> dict[str, Any]:
         "stock": _safe_non_negative_int(row["stock"]),
         "delivery_attributes": decode_json(row["delivery_attributes_json"], []),
         "handoff_destination": row["handoff_destination"] or "",
+        "floor_price": _safe_non_negative_float(row["floor_price"]),
+        "max_discount_percent": _safe_non_negative_float(row["max_discount_percent"]),
+        "promotions": decode_promotions(row["promotions_json"]),
         "merchant": merchant,
         "delivery": merchant["delivery"],
         "warnings": product_warnings(row, merchant),
@@ -991,6 +1210,7 @@ def search_products(
                dr.eta_minutes as delivery_eta_minutes,
                dr.radius_km as delivery_radius_km,
                dr.notes as delivery_notes,
+               dr.delivery_times_json as delivery_times_json,
                (
                    select count(*)
                    from products pc
@@ -1127,6 +1347,7 @@ def search_merchants(
                dr.eta_minutes as delivery_eta_minutes,
                dr.radius_km as delivery_radius_km,
                dr.notes as delivery_notes,
+               dr.delivery_times_json as delivery_times_json,
                count(p.sku) as active_product_count
     """
     if use_index:

{shopping_cli-3.2.4 → shopping_cli-3.2.5}/shopping_cli/core/catalog_views.py

@@ -30,6 +30,10 @@ def public_product_summary(product: dict[str, Any]) -> dict[str, Any]:
     """
     summary = dict(product)
     summary.pop("handoff_destination", None)
+    # v26 — 商家私有价格边界：底价/折扣率/促销对买家一律剥离（public-only §7）。
+    summary.pop("floor_price", None)
+    summary.pop("max_discount_percent", None)
+    summary.pop("promotions", None)
     if "stock" in summary:
         stock = summary.pop("stock", None)
         summary["availability_hint"] = (

{shopping_cli-3.2.4 → shopping_cli-3.2.5}/shopping_cli/db/migrations.py

@@ -10,7 +10,7 @@ from typing import Callable
 
 from shopping_cli.core.tokens import is_sha256_digest, token_digest, token_prefix, token_suffix
 
-CURRENT_SCHEMA_VERSION = 25
+CURRENT_SCHEMA_VERSION = 27
 
 
 @dataclass(frozen=True)
@@ -529,6 +529,29 @@ def migration_025_negotiation_decision_idempotency(conn: sqlite3.Connection) ->
     )
 
 
+def migration_026_product_pricing_boundaries(conn: sqlite3.Connection) -> None:
+    """products 商家私有价格边界（结构化字段，替代 automation_boundaries 自由文本）。
+
+    底价/折扣/促销从「商家级自由文本 + 正则解析」迁移为「每商品结构化列」：
+    floor_price（底价，0=未设）、max_discount_percent（最大折扣率 0-100，0=无
+    折扣授权）、promotions_json（结构化促销数组）。三者均私有，买家投影剥离。
+    幂等加列（ensure_column 已存在列跳过）；存量行默认 0/[]，行为向后兼容。
+    """
+    ensure_column(conn, "products", "floor_price", "real not null default 0")
+    ensure_column(conn, "products", "max_discount_percent", "real not null default 0")
+    ensure_column(conn, "products", "promotions_json", "text not null default '[]'")
+
+
+def migration_027_delivery_times(conn: sqlite3.Connection) -> None:
+    """delivery_rules.delivery_times_json 列（商家按区域配送时效，发现指标）。
+
+    商家级一个字段：区域 → {min_days, max_days}（如 东北 3-4 天、华北 1-2 天）。
+    买家在发现/搜索阶段看到摘要（listings 投影 → commercial_hints.lead_time_hint）。
+    幂等加列（ensure_column 已存在列跳过）；存量行默认 '{}'，行为向后兼容。
+    """
+    ensure_column(conn, "delivery_rules", "delivery_times_json", "text not null default '{}'")
+
+
 MIGRATIONS: tuple[Migration, ...] = (
     Migration(1, "conversation_next_actor", migration_001_conversation_next_actor),
     Migration(2, "agent_runtime_columns", migration_002_agent_runtime_columns),
@@ -548,6 +571,8 @@ MIGRATIONS: tuple[Migration, ...] = (
     Migration(23, "remove_scheme_a_stub_merchants", migration_023_remove_scheme_a_stub_merchants),
     Migration(24, "product_source_csv_excel", migration_024_product_source_csv_excel),
     Migration(25, "negotiation_decision_idempotency", migration_025_negotiation_decision_idempotency),
+    Migration(26, "product_pricing_boundaries", migration_026_product_pricing_boundaries),
+    Migration(27, "delivery_times", migration_027_delivery_times),
 )
 
 

{shopping_cli-3.2.4 → shopping_cli-3.2.5}/shopping_cli/db/models.py

@@ -40,6 +40,14 @@ SCHEMA = [
         -- 交易入口（URL 类为 https URL；联系/会话类为 opaque ref），publish 时
         -- 同步进 catalog listing 的 handoff_destination_ref。
         handoff_destination text not null default '',
+        -- v26 — 商家私有价格边界（结构化字段，替代 automation_boundaries 自由文本）：
+        -- floor_price = 底价（最小成交价，0=未设）；max_discount_percent =
+        -- 最大授权折扣率 0-100（0=无折扣授权）；promotions_json = 结构化促销
+        -- 数组（商家私有）。三者均为私有，买家可见路径（public_product_summary）
+        -- 一律剥离；merchant owner 可见可改。
+        floor_price real not null default 0,
+        max_discount_percent real not null default 0,
+        promotions_json text not null default '[]',
         active integer not null default 1,
         source text not null default 'local'
             check(source in ('local','erp','csv_excel')),
@@ -80,6 +88,7 @@ SCHEMA = [
         eta_minutes integer not null default 0,
         radius_km real not null default 0,
         notes text not null default '',
+        delivery_times_json text not null default '{}',
         created_at text not null,
         updated_at text not null,
         foreign key (merchant_id) references merchants(id)

{shopping_cli-3.2.4 → shopping_cli-3.2.5}/shopping_cli/listings/projection.py

@@ -14,6 +14,7 @@ import sqlite3
 from datetime import datetime, timezone
 from typing import Any
 
+from shopping_cli.core.catalog import delivery_times, render_delivery_times_hint
 from shopping_cli.data_sources.erp_source import SOURCE_LOCAL
 
 
@@ -68,6 +69,18 @@ def project_product_listing(
         "regions": [],
         "tags": json.loads(row.get("tags_json") or "[]"),
     }
+    # 商家配送时效（按区域，如 东北 3-4 天）→ 公开发现 hint：买家在搜索/发现
+    # 阶段看到时效摘要与履约区域。商家级字段（delivery_rules.delivery_times_json），
+    # 由商家用 `delivery set-time` 维护；为空保持 regions:[] 且无 commercial_hints。
+    if merchant_id:
+        times = delivery_times(conn, merchant_id)
+        if times:
+            region_names = sorted(times.keys())
+            projection["regions"] = region_names
+            projection["commercial_hints"] = {
+                "fulfillment_regions": region_names,
+                "lead_time_hint": render_delivery_times_hint(times),
+            }
     # 每商品成交入口（KTH destination_ref）：商家自行维护，publish 时同步进
     # catalog listing 的 handoff_destination_ref。审查 S-M3：私有字段，缺省
     # 剥离；仅 owner（include_private=True）保留。

{shopping_cli-3.2.4 → shopping_cli-3.2.5}/shopping_cli/services/negotiation.py

@@ -514,7 +514,10 @@ def _merchant_gate(
     # SKU 复用/重建时会对错误商家的 automation_boundaries 做 floor/折扣判断。
     # 换用 _load_conversation_product（带归属校验，fail-closed）。
     product = _load_conversation_product(conn, conversation)
-    floor_str = merchant_agent._authorized_bargain_amount(product)
+    # v26：结构化底价/折扣优先（floor_price / max_discount_percent），回退
+    # automation_boundaries 自由文本正则（_effective_floor_price 内部处理）。
+    effective_floor = merchant_agent._effective_floor_price(product)
+    floor_str = str(effective_floor) if effective_floor is not None else ""
     # 泄漏守卫对每个 merchant 决策运行——ask/decline 等无 proposal 的决策
     # 也可能携带泄露底价的 public_message（此前该分支直接放行）。
     if floor_str and _leaks_private_threshold(str(decision.get("public_message") or ""), floor_str):
@@ -533,8 +536,8 @@ def _merchant_gate(
     if age > protocol.STOCK_OBSERVATION_MAX_AGE_SECONDS or age < -60:
         return _reject("stale_inventory", "库存观察时间已过期，请重新获取快照后再报价。")
     unit_price = float(proposal["unit_price"])
-    if floor_str:
-        if unit_price < float(floor_str):
+    if effective_floor is not None:
+        if unit_price < effective_floor:
             return _human("below_floor", "报价低于商家授权的自动磋商范围，需要人工处理。")
     elif unit_price < float(product["price"]):
         return _human("unauthorized_discount", "该折扣没有商家授权规则，需要人工处理。")

{shopping_cli-3.2.4 → shopping_cli-3.2.5}/shopping_cli/services/negotiation_gates.py

@@ -8,9 +8,11 @@ writing, mutating shared state, or changing turn/state transitions.
 
 The merchant gate stays in :mod:`shopping_cli.services.negotiation`: it reads
 the merchant automation boundary floor through
-``merchant_agent._authorized_bargain_amount`` — a cross-module private access
-that a pure leaf must not own. The facade imports ``check_proposal_facts``
-from here so the merchant gate keeps calling the identical shared check.
+``merchant_agent._effective_floor_price`` (structured ``floor_price`` /
+``max_discount_percent`` first, free-text ``automation_boundaries`` fallback) —
+a cross-module private access that a pure leaf must not own. The facade imports
+``check_proposal_facts`` from here so the merchant gate keeps calling the
+identical shared check.
 """
 
 from __future__ import annotations

{shopping_cli-3.2.4 → shopping_cli-3.2.5/shopping_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: shopping-cli
-Version: 3.2.4
+Version: 3.2.5
 Summary: Standalone local-commerce AI consultation marketplace runtime
 License:                                  Apache License
                                    Version 2.0, January 2004