dongchedi-cli 0.2.0__tar.gz → 0.4.0__tar.gz

{dongchedi_cli-0.2.0 → dongchedi_cli-0.4.0}/.gitignore

@@ -7,3 +7,4 @@ build/
 *.egg-info/
 __pycache__/
 .ruff_cache/
+uv.lock

{dongchedi_cli-0.2.0 → dongchedi_cli-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: dongchedi-cli
-Version: 0.2.0
+Version: 0.4.0
 Summary: 懂车帝（dongchedi.com）数据查询 CLI：销量榜 / 品牌 / 车系 / 车型库筛选 / 车型 / 参数配置 / 车主评论 / 搜索
 Author: weisanju
 Keywords: automobile,car,cli,dongchedi,vehicle-data
@@ -46,8 +46,15 @@ dcd filter --price 10,20 --fuel 纯电 --body 轿车   # 车型库筛选：10-20
 dcd filter --body 小型SUV         # 全部小型SUV（级别细分，如 紧凑型SUV/中大型车/中型MPV）
 dcd filter --price 10, --fuel 新能源 --sort 销量高 -n 50   # 10万以上新能源，按销量排序
 dcd cars 20154                    # 星愿的车型年款与价格（含停售/未上市）
-dcd specs 20154 259371            # 车型参数配置表
+dcd cars 26051 -k 700 --fuel 纯电 # 车型筛选：名称含 700 的纯电车型（大小写不敏感）
+dcd cars 26051 --price 15,17      # 按指导价筛选（万，一侧留空表示不限）
+dcd specs 20154 259371            # 车型参数配置表（默认按 ◆ 章节/◇ 子章节分类）
 dcd specs 20154 259371 259369 -s 电池   # 多车对比，只看"电池"章节
+dcd specs 26051 261982 257691 -d  # 差异对比：只显示配置不同的项（至少 2 款车型）
+dcd specs 26051:261982 26012:261406        # 跨车系对比：车系ID:车型ID 配对（启源Q06 vs MG 07 EV）
+dcd specs 26051 261982 26012:261406 -d     # 混用：首个参数为默认车系，其余可写 车系:车型
+dcd specs 26051 --all             # 全系可查配置车型横向对比
+dcd specs 26051 --all --price 15,17 --fuel 纯电 -s 电池   # 全系筛选后对比
 dcd reviews 20154 -p 1 -n 20      # 车主评论（含成交价/评分）
 dcd search 秦plus                 # 搜车系
 dcd dealer 259371                 # 某车型的经销商报价与优惠（默认杭州）
@@ -88,8 +95,8 @@ Cookie 文件解析优先级：`--cookie-file` 参数 → `DCD_COOKIE_FILE` 环
 | brands | `GET /motor/brand/v4/brand/` | 品牌在 `data[].info`（其中 4 个热门品牌在 `info.brand`） |
 | series | `POST /motor/pc/car/brand/select_series_v2` | 表单参数是 `brand`（不是 `brand_id`，传错会静默返回全站热门车系） |
 | filter | `POST /motor/pc/car/brand/select_series_v2` | 与 series 同接口，隐藏筛选参数：`price="10,20"`（万元，区间重叠即命中，`-1` 表示不限）、`fuel_form`（1汽油/2柴油/3油电混合/4纯电/5增程/6插混/13轻混）、`series_type`（0轿车/1SUV/2MPV…）、`outter_detail_type`（细分级别：10小型SUV/11紧凑型SUV…）；`page` 分页有效，总数在 `data.series_count`；枚举出自车型库页前端 chunk（2026-09 逐项实测） |
-| cars | `GET /motor/pc/car/series/car_list` | `data.tab_list[]`，type 1115=车型、1137=年款分组，1068 为占位需跳过 |
-| specs | `GET /motor/pc/car/get_full_config_info` | 需 `series_id` + `car_ids`；实测忽略 car_ids，总是返回全车系，CLI 已按请求过滤 |
+| cars | `GET /motor/pc/car/series/car_list` | `data.tab_list[]`，type 1115=车型、1137=年款分组，1068 为占位需跳过；`-k/--price/--fuel` 为本地筛选，能源取自配置接口 `car_info[].info.fuel_form.value`（纯电动/增程式/插电式混合动力/汽油/油电混合/48V轻混系统，子串匹配），筛选时按 car_id 去重（同一车型会同时出现在「在售」与年款 tab） |
+| specs | `GET /motor/pc/car/get_full_config_info` | 需 `series_id` + `car_ids`；实测忽略 car_ids，总是返回全车系，CLI 已按请求过滤（返回车型与 car_list 不完全一致，约只含可查配置/在售车型）；`--all` 一次取全系在本地筛选；默认按 `◆` 章节/`◇` 子章节分层渲染，`-d/--diff` 只保留各车型取值不全相同的行；跨车系用 `车系ID:车型ID` 配对，每个车系各请求一次后按行名合并，`-j` 多车系输出 `{车系ID: 原始数据}` |
 | reviews | `GET /motor/pc/car/series/get_review_list` | 需 `Referer: /auto/series/score/{series_id}` |
 | search | `GET /motor/searchapi/search_content` | `cur_tab=2`，车系卡片为 `cell_type=5002`（不一定出现，无则回退内容标题） |
 | dealer | `GET /motor/pc/car/series/car_dealer_price` | 匿名可用；依赖 `city_name`（全国 → 暂无报价），未覆盖城市会回落邻近城市 |
@@ -106,6 +113,10 @@ Cookie 文件解析优先级：`--cookie-file` 参数 → `DCD_COOKIE_FILE` 环
 - 登录态 Cookie 含中文值，urllib 请求头默认 latin-1 编码，发送前已转 UTF-8 裸字节（与浏览器线上行为一致）。
 - 参数配置表字段：`data.properties[]` 为行定义（type 0/2 为章节标题，1 普通行，3 带子项，6 跳过），值在 `data.car_info[].info[<key>].value`；type 3 的值挂在 `sub_list[].key` 上。注意 `type` 字段时而为 int 时而为字符串，代码里已统一归一化。
 - 车型库筛选中 `series_type` 与 `outter_detail_type` **互斥**：同传时服务端会忽略后者（按大类返回）；CLI 的 `--body` 已自动只传其一（轿车/SUV 传 series_type，小型SUV 等细分传 outter_detail_type）。
+- 年款分组标题的「/ 后缀」不一定是能源：奥迪A6L 是世代代号（/ C9、/ C8），部分车系无后缀（钛7 PHEV）。`cars --fuel` 不解析标题，统一以配置接口的「能源类型」为准；因此只覆盖可查配置的车型，停售车型若无配置数据会被筛掉。
+- `cars` / `specs --all` 的筛选均在本地完成；`--json` 始终输出接口原始数据、不受筛选影响。筛选无匹配时：`cars` 输出空表（退出码 0，提示在 stderr），`specs --all` 报错（退出码 1）。
+- `specs -d/--diff` 行保留条件为各车型取值去重后 >1（`-` 视为相同值）；无差异的章节/子章节整段省略，汇总写 stderr（`差异 N 项 / 共 M 项`），无差异时 stdout 为空、退出码 0；最终参与对比车型不足 2 款报错（退出码 1）。
+- `specs` 跨车系对比：位置参数可写 `车系ID:车型ID`；首个参数无冒号时作为其余裸车型ID的默认车系（如 `specs 26051 261982 26012:261406`），与 `--all` 不可同时使用。合并按行名 `(key, text)` 对齐，行序以先出现的车系为准；某车系没有的行，该列回退取同行其他车系的定义渲染（通常显示 `-`）。列标题在多车系时带上车系名（如 `MG 07 EV 845 旗舰版`）；每个车系各发一次请求，跨 N 个车系即 N 次网络请求。
 - 接口可能随版本变化（版本参数当前为 version_code=476），失效时优先用 `--json` 排查原始返回。
 
 ## 开发与发布

{dongchedi_cli-0.2.0 → dongchedi_cli-0.4.0}/README.md

@@ -26,8 +26,15 @@ dcd filter --price 10,20 --fuel 纯电 --body 轿车   # 车型库筛选：10-20
 dcd filter --body 小型SUV         # 全部小型SUV（级别细分，如 紧凑型SUV/中大型车/中型MPV）
 dcd filter --price 10, --fuel 新能源 --sort 销量高 -n 50   # 10万以上新能源，按销量排序
 dcd cars 20154                    # 星愿的车型年款与价格（含停售/未上市）
-dcd specs 20154 259371            # 车型参数配置表
+dcd cars 26051 -k 700 --fuel 纯电 # 车型筛选：名称含 700 的纯电车型（大小写不敏感）
+dcd cars 26051 --price 15,17      # 按指导价筛选（万，一侧留空表示不限）
+dcd specs 20154 259371            # 车型参数配置表（默认按 ◆ 章节/◇ 子章节分类）
 dcd specs 20154 259371 259369 -s 电池   # 多车对比，只看"电池"章节
+dcd specs 26051 261982 257691 -d  # 差异对比：只显示配置不同的项（至少 2 款车型）
+dcd specs 26051:261982 26012:261406        # 跨车系对比：车系ID:车型ID 配对（启源Q06 vs MG 07 EV）
+dcd specs 26051 261982 26012:261406 -d     # 混用：首个参数为默认车系，其余可写 车系:车型
+dcd specs 26051 --all             # 全系可查配置车型横向对比
+dcd specs 26051 --all --price 15,17 --fuel 纯电 -s 电池   # 全系筛选后对比
 dcd reviews 20154 -p 1 -n 20      # 车主评论（含成交价/评分）
 dcd search 秦plus                 # 搜车系
 dcd dealer 259371                 # 某车型的经销商报价与优惠（默认杭州）
@@ -68,8 +75,8 @@ Cookie 文件解析优先级：`--cookie-file` 参数 → `DCD_COOKIE_FILE` 环
 | brands | `GET /motor/brand/v4/brand/` | 品牌在 `data[].info`（其中 4 个热门品牌在 `info.brand`） |
 | series | `POST /motor/pc/car/brand/select_series_v2` | 表单参数是 `brand`（不是 `brand_id`，传错会静默返回全站热门车系） |
 | filter | `POST /motor/pc/car/brand/select_series_v2` | 与 series 同接口，隐藏筛选参数：`price="10,20"`（万元，区间重叠即命中，`-1` 表示不限）、`fuel_form`（1汽油/2柴油/3油电混合/4纯电/5增程/6插混/13轻混）、`series_type`（0轿车/1SUV/2MPV…）、`outter_detail_type`（细分级别：10小型SUV/11紧凑型SUV…）；`page` 分页有效，总数在 `data.series_count`；枚举出自车型库页前端 chunk（2026-09 逐项实测） |
-| cars | `GET /motor/pc/car/series/car_list` | `data.tab_list[]`，type 1115=车型、1137=年款分组，1068 为占位需跳过 |
-| specs | `GET /motor/pc/car/get_full_config_info` | 需 `series_id` + `car_ids`；实测忽略 car_ids，总是返回全车系，CLI 已按请求过滤 |
+| cars | `GET /motor/pc/car/series/car_list` | `data.tab_list[]`，type 1115=车型、1137=年款分组，1068 为占位需跳过；`-k/--price/--fuel` 为本地筛选，能源取自配置接口 `car_info[].info.fuel_form.value`（纯电动/增程式/插电式混合动力/汽油/油电混合/48V轻混系统，子串匹配），筛选时按 car_id 去重（同一车型会同时出现在「在售」与年款 tab） |
+| specs | `GET /motor/pc/car/get_full_config_info` | 需 `series_id` + `car_ids`；实测忽略 car_ids，总是返回全车系，CLI 已按请求过滤（返回车型与 car_list 不完全一致，约只含可查配置/在售车型）；`--all` 一次取全系在本地筛选；默认按 `◆` 章节/`◇` 子章节分层渲染，`-d/--diff` 只保留各车型取值不全相同的行；跨车系用 `车系ID:车型ID` 配对，每个车系各请求一次后按行名合并，`-j` 多车系输出 `{车系ID: 原始数据}` |
 | reviews | `GET /motor/pc/car/series/get_review_list` | 需 `Referer: /auto/series/score/{series_id}` |
 | search | `GET /motor/searchapi/search_content` | `cur_tab=2`，车系卡片为 `cell_type=5002`（不一定出现，无则回退内容标题） |
 | dealer | `GET /motor/pc/car/series/car_dealer_price` | 匿名可用；依赖 `city_name`（全国 → 暂无报价），未覆盖城市会回落邻近城市 |
@@ -86,6 +93,10 @@ Cookie 文件解析优先级：`--cookie-file` 参数 → `DCD_COOKIE_FILE` 环
 - 登录态 Cookie 含中文值，urllib 请求头默认 latin-1 编码，发送前已转 UTF-8 裸字节（与浏览器线上行为一致）。
 - 参数配置表字段：`data.properties[]` 为行定义（type 0/2 为章节标题，1 普通行，3 带子项，6 跳过），值在 `data.car_info[].info[<key>].value`；type 3 的值挂在 `sub_list[].key` 上。注意 `type` 字段时而为 int 时而为字符串，代码里已统一归一化。
 - 车型库筛选中 `series_type` 与 `outter_detail_type` **互斥**：同传时服务端会忽略后者（按大类返回）；CLI 的 `--body` 已自动只传其一（轿车/SUV 传 series_type，小型SUV 等细分传 outter_detail_type）。
+- 年款分组标题的「/ 后缀」不一定是能源：奥迪A6L 是世代代号（/ C9、/ C8），部分车系无后缀（钛7 PHEV）。`cars --fuel` 不解析标题，统一以配置接口的「能源类型」为准；因此只覆盖可查配置的车型，停售车型若无配置数据会被筛掉。
+- `cars` / `specs --all` 的筛选均在本地完成；`--json` 始终输出接口原始数据、不受筛选影响。筛选无匹配时：`cars` 输出空表（退出码 0，提示在 stderr），`specs --all` 报错（退出码 1）。
+- `specs -d/--diff` 行保留条件为各车型取值去重后 >1（`-` 视为相同值）；无差异的章节/子章节整段省略，汇总写 stderr（`差异 N 项 / 共 M 项`），无差异时 stdout 为空、退出码 0；最终参与对比车型不足 2 款报错（退出码 1）。
+- `specs` 跨车系对比：位置参数可写 `车系ID:车型ID`；首个参数无冒号时作为其余裸车型ID的默认车系（如 `specs 26051 261982 26012:261406`），与 `--all` 不可同时使用。合并按行名 `(key, text)` 对齐，行序以先出现的车系为准；某车系没有的行，该列回退取同行其他车系的定义渲染（通常显示 `-`）。列标题在多车系时带上车系名（如 `MG 07 EV 845 旗舰版`）；每个车系各发一次请求，跨 N 个车系即 N 次网络请求。
 - 接口可能随版本变化（版本参数当前为 version_code=476），失效时优先用 `--json` 排查原始返回。
 
 ## 开发与发布

{dongchedi_cli-0.2.0 → dongchedi_cli-0.4.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "dongchedi-cli"
-version = "0.2.0"
+version = "0.4.0"
 description = "懂车帝（dongchedi.com）数据查询 CLI：销量榜 / 品牌 / 车系 / 车型库筛选 / 车型 / 参数配置 / 车主评论 / 搜索"
 readme = "README.md"
 requires-python = ">=3.10"

{dongchedi_cli-0.2.0 → dongchedi_cli-0.4.0}/src/dongchedi_cli/__init__.py

@@ -1,3 +1,3 @@
 """懂车帝数据查询 CLI。"""
 
-__version__ = "0.2.0"
+__version__ = "0.4.0"

{dongchedi_cli-0.2.0 → dongchedi_cli-0.4.0}/src/dongchedi_cli/cli.py

@@ -3,6 +3,8 @@
 免登录子命令：rank / brands / series / filter / cars / specs / reviews / search / dealer
 需登录态子命令：series-info（HTML SSR）/ me（账号信息）
 
+cars 可按 关键字/价格/能源 筛选；specs 默认按分类（◆/◇）对比，支持 车系:车型 跨车系配对，--all 对比全系并叠加同一套筛选，-d 只看差异项
+
 登录态来源（auth-import 写入，或 --cookie-file / DCD_COOKIE_FILE 指定）：
   dcd auth-import <playwright-state.json>  # playwright-cli state-save 的产物
 
@@ -420,13 +422,19 @@ SORTS = {
 }
 
 
-def parse_price(text: str) -> str:
-    """'10,20' -> '10,20'；一侧留空表示不限：'10,' -> '10,-1'，',20' -> '0,20'。"""
+def parse_price_range(text: str) -> tuple[str | None, str | None]:
+    """'10,20' -> ('10','20')；一侧留空表示不限：'10,' -> ('10',None)，',20' -> (None,'20')。"""
     normalized = text.replace("万", "").replace("，", ",").replace("～", "~")
     match = re.fullmatch(r"\s*(\d+(?:\.\d+)?)?\s*[,\-~]\s*(\d+(?:\.\d+)?)?\s*", normalized)
     if not match or (not match.group(1) and not match.group(2)):
         raise DcdError('价格格式应为 "最低,最高"（单位万），如 "10,20"；一侧留空表示不限，如 "10,"')
-    return f"{match.group(1) or '0'},{match.group(2) or '-1'}"
+    return match.group(1), match.group(2)
+
+
+def parse_price(text: str) -> str:
+    """'10,20' -> '10,20'；一侧留空表示不限：'10,' -> '10,-1'，',20' -> '0,20'。"""
+    low, high = parse_price_range(text)
+    return f"{low or '0'},{high or '-1'}"
 
 
 def resolve_fuel(text: str) -> str:
@@ -502,6 +510,99 @@ def cmd_filter(args) -> None:
     print_series_table(series)
 
 
+# ---------- 车系内筛选（cars / specs --all 共用） ----------
+
+# 配置接口的能源类型实际取值：纯电动 / 增程式 / 插电式混合动力 / 汽油 / 油电混合 / 48V轻混系统
+# 按子串匹配，别名与 filter 子命令保持一致
+FUEL_TEXTS = {
+    "新能源": ("纯电", "增程", "插电"),
+    "纯电": ("纯电",),
+    "纯电动": ("纯电",),
+    "增程": ("增程",),
+    "增程式": ("增程",),
+    "插混": ("插电",),
+    "插电混动": ("插电",),
+    "插电式混合动力": ("插电",),
+    "汽油": ("汽油",),
+    "柴油": ("柴油",),
+    "油电混动": ("油电",),
+    "油电混合": ("油电",),
+    "轻混": ("轻混", "48V"),
+    "48V轻混": ("轻混", "48V"),
+}
+
+
+def resolve_fuel_text(text: str) -> tuple[str, ...]:
+    key = text.strip()
+    if key in FUEL_TEXTS:
+        return FUEL_TEXTS[key]
+    raise DcdError(
+        f"未知能源 {text!r}；可用: 新能源/纯电/增程/插混/汽油/柴油/油电混动/轻混"
+    )
+
+
+def parse_wan(value) -> float | None:
+    """车系接口指导价是浮点，配置接口是 '13.99万' 字符串，统一为数字（万）。"""
+    if isinstance(value, (int, float)):
+        return float(value)
+    match = re.fullmatch(r"\s*(\d+(?:\.\d+)?)\s*万?\s*", str(value or ""))
+    return float(match.group(1)) if match else None
+
+
+def car_energy(car: dict) -> str:
+    return (((car.get("info") or {}).get("fuel_form") or {}).get("value") or "").strip()
+
+
+def matches_keyword(name: str, keyword: str) -> bool:
+    return keyword.lower() in name.lower()
+
+
+def matches_price(price_wan: float | None, bounds: tuple[float | None, float | None]) -> bool:
+    if price_wan is None:
+        return False
+    low, high = bounds
+    if low is not None and price_wan < low:
+        return False
+    return high is None or price_wan <= high
+
+
+def matches_fuel(energy: str, texts: tuple[str, ...]) -> bool:
+    return bool(energy) and any(t in energy for t in texts)
+
+
+def parse_price_bounds(text: str) -> tuple[float | None, float | None]:
+    low, high = parse_price_range(text)
+    return (float(low) if low else None, float(high) if high else None)
+
+
+def fetch_car_fuels(series_id) -> dict[str, str]:
+    """车系内全部可查配置车型的能源类型：car_id -> fuel_form。"""
+    payload = api_get("/motor/pc/car/get_full_config_info", {"series_id": series_id})
+    fuels = {}
+    for car in (payload.get("data") or {}).get("car_info") or []:
+        cid = car.get("car_id")
+        if cid is not None:
+            fuels[str(cid)] = car_energy(car)
+    return fuels
+
+
+def filter_desc(keyword, price, fuel) -> str:
+    parts = []
+    if keyword:
+        parts.append(f"关键字 {keyword}")
+    if price:
+        low, high = parse_price_range(price)
+        if low and high:
+            parts.append(f"价格 {low}-{high}万")
+        elif low:
+            parts.append(f"价格 {low}万以上")
+        else:
+            parts.append(f"价格 {high}万以下")
+    if fuel:
+        parts.append(fuel)
+    return " · ".join(parts)
+
+
 def cmd_cars(args) -> None:
     payload = api_get(
         "/motor/pc/car/series/car_list",
@@ -510,27 +611,66 @@ def cmd_cars(args) -> None:
     if args.json:
         dump_json(payload)
         return
-    tabs = (payload.get("data") or {}).get("tab_list") or []
-    rows = []
-    for tab in tabs:
+    filtering = bool(args.keyword or args.price or args.fuel)
+    bounds = parse_price_bounds(args.price) if args.price else None
+    texts = resolve_fuel_text(args.fuel) if args.fuel else None
+    fuels = fetch_car_fuels(args.series_id) if texts else {}
+    seen: set[str] = set()
+    rows: list[list[str]] = []
+    header: list[str] | None = None
+    section: list[list[str]] = []
+
+    def flush() -> None:
+        # 筛选模式下整段无匹配的章节连标题一起隐藏
+        if not filtering or section:
+            if header:
+                rows.append(header)
+            rows.extend(section)
+
+    for tab in (payload.get("data") or {}).get("tab_list") or []:
         status = tab.get("tab_text") or ""
         for entry in tab.get("data") or []:
             info = entry.get("info") or {}
-            if entry.get("type") == "1068":
+            etype = entry.get("type")
+            if etype == "1068":
                 continue
-            if entry.get("type") == "1137":
-                rows.append([f"[{status}] {info.get('name') or ''}", "", "", "", "", ""])
+            if etype == "1137":
+                flush()
+                header = [f"[{status}] {info.get('name') or ''}", "", "", "", "", ""]
+                section = []
                 continue
-            rows.append(
+            name = info.get("car_name") or info.get("name") or ""
+            car_id = str(info.get("car_id") or info.get("id") or "")
+            if filtering:
+                if args.keyword and not matches_keyword(name, args.keyword):
+                    continue
+                if bounds and not matches_price(parse_wan(info.get("official_price")), bounds):
+                    continue
+                if texts and not matches_fuel(fuels.get(car_id, ""), texts):
+                    continue
+                # 同一车型会同时出现在「在售」与年款 tab，筛选时按 car_id 去重
+                if car_id and car_id in seen:
+                    continue
+                if car_id:
+                    seen.add(car_id)
+            section.append(
                 [
-                    info.get("car_name") or info.get("name") or "",
+                    name,
                     str(info.get("year") or ""),
                     info.get("official_price_str") or "",
                     info.get("dealer_price") or "",
                     info.get("owner_price") or "",
-                    str(info.get("car_id") or info.get("id") or ""),
+                    car_id,
                 ]
             )
+    flush()
+    if filtering:
+        matched = sum(1 for r in rows if r[5])
+        desc = filter_desc(args.keyword, args.price, args.fuel)
+        if matched:
+            print(f"筛选后 {matched} 款（{desc}）", file=sys.stderr)
+        else:
+            print(f"没有匹配的车型（{desc}）", file=sys.stderr)
     print(render_table(["车型", "年款", "官方指导价", "经销商价", "车主价", "车型ID"], rows))
 
 
@@ -560,51 +700,249 @@ def _spec_value(car: dict, prop: dict) -> str:
 
 
 def cmd_specs(args) -> None:
-    car_ids = [cid for raw in args.car_id for cid in raw.split(",") if cid]
-    payload = api_get(
-        "/motor/pc/car/get_full_config_info",
-        {"series_id": args.series_id, "car_ids": ",".join(car_ids)},
-    )
-    if args.json:
-        dump_json(payload)
-        return
-    data = payload["data"]
-    cars = data.get("car_info") or []
-    if not cars:
-        raise DcdError(f"未找到车型配置: {', '.join(car_ids)}")
-    # 实测该接口忽略 car_ids，总是返回整个车系，这里按请求过滤
-    by_id = {str(c.get("car_id")): c for c in cars}
-    missing = [cid for cid in car_ids if cid not in by_id]
-    if missing:
-        raise DcdError(f"车系 {args.series_id} 下不存在车型: {', '.join(missing)}")
-    cars = [by_id[cid] for cid in car_ids]
-    headers = ["参数"] + [c.get("car_name") or str(c.get("car_id")) for c in cars]
-    rows: list[list[str]] = []
-    section = ""
-    for prop in data.get("properties") or []:
-        ptype = _ptype(prop)
-        text = prop.get("text") or ""
-        if ptype == 0:
-            section = text
-            if args.section and args.section in section:
-                rows.append([f"◆ {text}", *[""] * len(cars)])
-            continue
-        if args.section and args.section not in section:
-            continue
-        if ptype == 2:
-            rows.append([f"◇ {text}", *[""] * len(cars)])
-            continue
-        if ptype == 6:
-            continue
-        rows.append([text, *[_spec_value(car, prop) for car in cars]])
-    if args.section and not rows:
-        names = [
-            p.get("text") or "" for p in data.get("properties") or [] if _ptype(p) == 0
+    if args.all and args.car_id:
+        raise DcdError("--all 与车型ID 不能同时使用")
+    if args.all and ":" in args.series_id:
+        raise DcdError("--all 模式下不能使用「车系:车型」格式")
+    if not args.all and (args.keyword or args.price or args.fuel):
+        raise DcdError(
+            "--keyword/--price/--fuel 需配合 --all 使用，如: dcd specs 26051 --all --fuel 纯电"
+        )
+
+    if args.all:
+        payload = api_get(
+            "/motor/pc/car/get_full_config_info",
+            {"series_id": args.series_id, "car_ids": ""},
+        )
+        if args.json:
+            dump_json(payload)
+            return
+        data = payload["data"]
+        cars = data.get("car_info") or []
+        bounds = parse_price_bounds(args.price) if args.price else None
+        texts = resolve_fuel_text(args.fuel) if args.fuel else None
+        cars = [
+            car
+            for car in cars
+            if (not args.keyword or matches_keyword(car.get("car_name") or "", args.keyword))
+            and (not bounds or matches_price(parse_wan(car.get("official_price")), bounds))
+            and (not texts or matches_fuel(car_energy(car), texts))
         ]
+        desc = filter_desc(args.keyword, args.price, args.fuel)
+        if not cars:
+            raise DcdError(f"全系没有匹配的车型（{desc}）")
+        print(f"全系 {len(cars)} 款" + (f"（{desc}）" if desc else ""), file=sys.stderr)
+        series_order = [args.series_id]
+        data_by_series = {args.series_id: data}
+        resolved = [(car, args.series_id) for car in cars]
+    else:
+        # 支持 车系ID:车型ID 配对（跨车系对比）；首个位置参数无冒号时作为默认车系
+        specs: list[tuple[str, str]] = []
+        default_series: str | None = None
+        if ":" in args.series_id:
+            series, _, cid = args.series_id.partition(":")
+            if not series or not cid:
+                raise DcdError(f"无效的「车系:车型」格式: {args.series_id}")
+            specs.append((series, cid))
+        else:
+            default_series = args.series_id
+        for raw in args.car_id:
+            for token in raw.split(","):
+                if not token:
+                    continue
+                if ":" in token:
+                    series, _, cid = token.partition(":")
+                    if not series or not cid:
+                        raise DcdError(f"无效的「车系:车型」格式: {token}")
+                    specs.append((series, cid))
+                elif default_series is None:
+                    raise DcdError(
+                        f"车型 {token} 缺少车系，请写作 车系:车型（如 26051:{token}）"
+                    )
+                else:
+                    specs.append((default_series, token))
+        if not specs:
+            raise DcdError(
+                "需要车型ID（可多个，逗号分隔），或用 --all 对比全系可查配置车型；车型ID 用 dcd cars 查"
+            )
+
+        by_series: dict[str, list[str]] = {}
+        series_order: list[str] = []
+        for series, cid in specs:
+            if series not in by_series:
+                by_series[series] = []
+                series_order.append(series)
+            by_series[series].append(cid)
+        payloads = {
+            series: api_get(
+                "/motor/pc/car/get_full_config_info",
+                {"series_id": series, "car_ids": ",".join(by_series[series])},
+            )
+            for series in series_order
+        }
+        if args.json:
+            if len(series_order) == 1:
+                dump_json(payloads[series_order[0]])
+            else:
+                dump_json({series: payloads[series] for series in series_order})
+            return
+
+        data_by_series = {series: payloads[series]["data"] for series in series_order}
+        # 实测该接口忽略 car_ids，总是返回整个车系，这里按请求过滤
+        by_id_series: dict[str, dict[str, dict]] = {}
+        problems: list[str] = []
+        for series in series_order:
+            cars_s = data_by_series[series].get("car_info") or []
+            if not cars_s:
+                problems.append(f"未找到车型配置: {', '.join(by_series[series])}")
+                continue
+            by_id = {str(c.get("car_id")): c for c in cars_s}
+            by_id_series[series] = by_id
+            missing = [cid for cid in by_series[series] if cid not in by_id]
+            if missing:
+                problems.append(f"车系 {series} 下不存在车型: {', '.join(missing)}")
+        if problems:
+            raise DcdError("；".join(problems))
+        resolved = [(by_id_series[series][cid], series) for series, cid in specs]
+        if len(series_order) > 1:
+            print(f"跨车系对比：{'、'.join(series_order)}", file=sys.stderr)
+
+    cars = [car for car, _ in resolved]
+    if args.diff and len(cars) < 2:
+        raise DcdError(f"--diff 需要至少 2 款车型对比（当前 {len(cars)} 款）")
+    if len(series_order) > 1:
+        headers = ["参数"] + [
+            f"{car.get('series_name') or series} {car.get('car_name') or car.get('car_id')}"
+            for car, series in resolved
+        ]
+    else:
+        headers = ["参数"] + [c.get("car_name") or str(c.get("car_id")) for c in cars]
+
+    # 结构化为 章节 → 子章节 → 行；跨车系按 (key, text, 序号) 对齐，行序以先出现的车系为准
+    records: list[dict] = []
+    row_index: dict[tuple[tuple[str, str], int], dict] = {}
+    matched_section = False
+    for series in series_order:
+        cur_section: str | None = None
+        cur_sub: str | None = None
+        seen: dict[tuple[str, str], int] = {}
+        for prop in data_by_series[series].get("properties") or []:
+            ptype = _ptype(prop)
+            text = prop.get("text") or ""
+            if ptype == 0:
+                if args.section and args.section not in text:
+                    cur_section = cur_sub = None
+                    continue
+                matched_section = True
+                cur_section = text
+                cur_sub = None
+                continue
+            if cur_section is None and args.section:
+                continue
+            if ptype == 6:
+                continue
+            if cur_section is None:
+                cur_section = ""
+            if ptype == 2:
+                cur_sub = text
+                continue
+            if cur_sub is None:
+                cur_sub = ""
+            pair = (prop.get("key") or "", text)
+            ordinal = seen.get(pair, 0)
+            seen[pair] = ordinal + 1
+            ident = (pair, ordinal)
+            record = row_index.get(ident)
+            if record is None:
+                record = {
+                    "section": cur_section,
+                    "sub": cur_sub,
+                    "text": text,
+                    "props": {},
+                }
+                row_index[ident] = record
+                records.append(record)
+            if series not in record["props"]:
+                record["props"][series] = prop
+
+    sections: list[dict] = []
+    sec_map: dict[str, dict] = {}
+    sub_map: dict[tuple[str, str], dict] = {}
+    for record in records:
+        fallback = next(iter(record["props"].values()))
+        sec = sec_map.get(record["section"])
+        if sec is None:
+            sec = {"text": record["section"], "subs": []}
+            sec_map[record["section"]] = sec
+            sections.append(sec)
+        sub_key = (record["section"], record["sub"])
+        sub = sub_map.get(sub_key)
+        if sub is None:
+            sub = {"text": record["sub"], "rows": []}
+            sub_map[sub_key] = sub
+            sec["subs"].append(sub)
+        sub["rows"].append(
+            [
+                record["text"],
+                *[
+                    _spec_value(car, record["props"].get(series) or fallback)
+                    for car, series in resolved
+                ],
+            ]
+        )
+
+    rows: list[list[str]] = []
+    if args.section and not matched_section:
+        names: list[str] = []
+        for series in series_order:
+            for prop in data_by_series[series].get("properties") or []:
+                text = prop.get("text") or ""
+                if _ptype(prop) == 0 and text not in names:
+                    names.append(text)
         print(
             f"提示: 没有章节匹配 {args.section!r}，可用章节: {'、'.join(names)}",
             file=sys.stderr,
         )
+    elif args.diff:
+        # 差异模式：取值去重后 >1 才算差异行，无差异的章节/子章节整段省略
+        total = sum(len(sub["rows"]) for sec in sections for sub in sec["subs"])
+        kept = 0
+        for sec in sections:
+            sec_rows: list[list[str]] = []
+            for sub in sec["subs"]:
+                diff_rows = [r for r in sub["rows"] if len(set(r[1:])) > 1]
+                if not diff_rows:
+                    continue
+                if sub["text"]:
+                    sec_rows.append([f"◇ {sub['text']}", *[""] * len(cars)])
+                sec_rows.extend(diff_rows)
+                kept += len(diff_rows)
+            if not sec_rows:
+                continue
+            if sec["text"]:
+                rows.append([f"◆ {sec['text']}", *[""] * len(cars)])
+            rows.extend(sec_rows)
+        if kept:
+            print(
+                f"差异 {kept} 项 / 共 {total} 项（已隐藏相同 {total - kept} 项）",
+                file=sys.stderr,
+            )
+        else:
+            print(
+                f"未发现差异：{len(cars)} 款车型配置完全一致（共 {total} 项）",
+                file=sys.stderr,
+            )
+    else:
+        for sec in sections:
+            if sec["text"]:
+                rows.append([f"◆ {sec['text']}", *[""] * len(cars)])
+            for sub in sec["subs"]:
+                if sub["text"]:
+                    rows.append([f"◇ {sub['text']}", *[""] * len(cars)])
+                rows.extend(sub["rows"])
+
+    if args.diff and not rows:
+        return
     print(render_table(headers, rows))
 
 
@@ -912,15 +1250,40 @@ def build_parser() -> argparse.ArgumentParser:
     p.add_argument("-j", "--json", action="store_true", help="输出原始 JSON")
     p.set_defaults(func=cmd_filter)
 
-    p = sub.add_parser("cars", help="车系下的车型（年款/价格）")
+    p = sub.add_parser("cars", help="车系下的车型（年款/价格），可按条件筛选")
     p.add_argument("series_id", help="车系ID")
+    p.add_argument("-k", "--keyword", help="按车型名筛选（不区分大小写），如 700、max")
+    p.add_argument("--price", help='按指导价筛选（万），如 "15,17"；一侧留空表示不限')
+    p.add_argument(
+        "-f", "--fuel", help="按能源筛选：纯电/增程/插混/汽油/柴油/油电混动/新能源/轻混"
+    )
     p.add_argument("-j", "--json", action="store_true", help="输出原始 JSON")
     p.set_defaults(func=cmd_cars)
 
-    p = sub.add_parser("specs", help="车型参数配置表（可多车对比）")
-    p.add_argument("series_id", help="车系ID")
-    p.add_argument("car_id", nargs="+", help="车型ID，可多个（用 dcd cars 查）")
+    p = sub.add_parser(
+        "specs", help="车型参数配置表（按分类对比，支持 车系:车型 跨车系；-d 只看差异，--all 对比全系）"
+    )
+    p.add_argument("series_id", help="车系ID；跨车系可直接写 车系ID:车型ID")
+    p.add_argument(
+        "car_id",
+        nargs="*",
+        help="车型ID（可多个，逗号分隔；用 dcd cars 查），支持 车系ID:车型ID 跨车系配对；或用 --all 对比全系",
+    )
+    p.add_argument(
+        "--all", action="store_true", help="对比全系可查配置车型，可叠加 --keyword/--price/--fuel"
+    )
+    p.add_argument("-k", "--keyword", help="按车型名筛选（需 --all），如 Max、四驱")
+    p.add_argument("--price", help='按指导价筛选（需 --all，万），如 "15,17"')
+    p.add_argument(
+        "-f", "--fuel", help="按能源筛选（需 --all）：纯电/增程/插混/汽油/油电混动/新能源/轻混"
+    )
     p.add_argument("-s", "--section", help="只看包含该文字的章节，如 电池")
+    p.add_argument(
+        "-d",
+        "--diff",
+        action="store_true",
+        help="只显示各车型取值不同的配置项（至少 2 款车型，无差异章节自动省略）",
+    )
     p.add_argument("-j", "--json", action="store_true", help="输出原始 JSON")
     p.set_defaults(func=cmd_specs)