PyClickerRPA 0.3.1__tar.gz → 0.5.0__tar.gz

{pyclickerrpa-0.3.1 → pyclickerrpa-0.5.0}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: PyClickerRPA
-Version: 0.3.1
-Summary: Visual UI automation & testing tool: Windows + Android(ADB) automation, robust/self-healing image matching, OCR, node flow editor, recorder, a visual test framework (assertions, visual regression, HTML/JUnit reports) and a web console.
+Version: 0.5.0
+Summary: Visual UI automation & testing tool: Windows + Android(ADB) automation, robust/self-healing image matching, OCR, node flow editor, a smart recorder that records images instead of coordinates, task health checks and failure attribution, a visual test framework (assertions, visual regression, HTML/JUnit reports) and a web console.
 Author: Equinox
 License-Expression: MIT
 Project-URL: Homepage, https://github.com/Equinox/PyClickerRPA
@@ -66,6 +66,7 @@ pip install "PyClickerRPA[web]"   # FastAPI + uvicorn — web console
 autoclicker                          # desktop GUI (flow editor / list editor / test tab)
 autoclicker-run task.json --window "Notepad"   # headless run against a window
 autoclicker-run task.json --adb                # run against an Android device (adb)
+autoclicker-lint task.json                     # health-check a task (exit code = error count)
 autoclicker-testkit suite.json --report out.html --junit out.xml   # run a test suite
 autoclicker-web --suites-dir examples          # web console at http://127.0.0.1:8000
 ```
@@ -82,7 +83,7 @@ autoclicker-web --suites-dir examples          # web console at http://127.0.0.1
 - **Smart wait**: `wait_stable` waits until the screen (or an ROI) stops
   changing — replaces guessed `sleep`s (fast when ready, patient when slow).
 - **~30+ step types**: click image/text/position, click-all, relative/offset
-  clicks, wait / random / wait-stable, drag / long-press / pinch / scroll,
+  clicks, wait / random / wait-stable, drag / **drag-from-image** / long-press / pinch / scroll,
   key / type / hotkey, loop / goto / while / do-until, if image/text/color/
   count/var with **true/false branching** (if-else), set-var, read-text→variable,
   activate-window, HTTP request, run-Python-script, call sub-task, groups, and a
@@ -93,12 +94,57 @@ autoclicker-web --suites-dir examples          # web console at http://127.0.0.1
 Drag-and-drop **node flow graph** (condition nodes have **true/false branch
 ports** for visual if-else; a terminal **stop** node ends the flow) and an
 interoperable **step list** with a full
-per-step dialog; an action **recorder** (global hooks), snippet library, task
+per-step dialog; snippet library, task
 packages (`.zip` with templates), on-preview coordinate/color picking, template
 crop, single-step test run; global hotkeys (F6 run/stop, ESC stop), scheduler,
 and an image/color **monitor/trigger** with tray icon; a **Test** tab to load and
 run visual test suites.
 
+### Smart recorder
+
+The action **recorder** (global hooks) doesn't just replay coordinates and
+sleeps — with **智能录制 / smart mode** on (default) it records what things *look
+like* instead of where they *were*:
+
+- **Clicks become image steps.** A patch is cropped around the click and grown
+  (48 → 192 px) until it is both textured enough and **unique on screen**, then
+  emitted as a `click_image` step — so the flow still works after the window
+  moves or the resolution changes. Identical patches are de-duplicated by
+  content hash.
+- **Drags become `drag_image`.** The drag's *start* is anchored to an image and
+  the *displacement* is stored, so start and end move together.
+- **Pauses become `wait_stable`.** A long pause is only converted if the
+  recorder actually **observed the screen settle** during it; on a permanently
+  animating screen it keeps the fixed wait (a `wait_stable` that never settles
+  would fail the run).
+
+Anything that can't be made robust falls back to the plain coordinate/fixed-wait
+step and says why in the log.
+
+## Diagnostics
+
+**Task health check** (`autoclicker-lint task.json`, or 诊断 → 任务体检 in the GUI)
+statically scans a task and separates *will definitely break* from *works but
+fragile*:
+
+- **errors** — missing template / sub-task file, image step with no template,
+  loop / goto / fail-jump target out of range, unbalanced groups. The GUI asks
+  for confirmation before running a task with errors; the CLI exit code is the
+  error count.
+- **warnings** — steps that depend on absolute coordinates, long fixed waits,
+  a match threshold low enough to hit the wrong thing, templates too small to be
+  unique. These are exactly the things the smart recorder now avoids, so the
+  check doubles as a "what should I re-record?" list.
+
+**Failure attribution.** A run captures a screenshot per step; the first
+successful run becomes the baseline timeline (`.timelines/<task>/`). When a later
+run fails, the frames are compared step by step and the report names the step
+where the screen **first diverged** from the successful run — which is usually
+*earlier* than the step that failed (step 7 can't find its button because a popup
+appeared at step 4). You get the diverging step, the per-step changed-pixel
+ratios, and a baseline|actual|heatmap image. If the screens match, it says so —
+that points at timing/flakiness rather than a UI change.
+
 ## Visual test framework (`autoclicker.testkit`)
 
 Turn automation into tests:

{pyclickerrpa-0.3.1 → pyclickerrpa-0.5.0}/PyClickerRPA.egg-info/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: PyClickerRPA
-Version: 0.3.1
-Summary: Visual UI automation & testing tool: Windows + Android(ADB) automation, robust/self-healing image matching, OCR, node flow editor, recorder, a visual test framework (assertions, visual regression, HTML/JUnit reports) and a web console.
+Version: 0.5.0
+Summary: Visual UI automation & testing tool: Windows + Android(ADB) automation, robust/self-healing image matching, OCR, node flow editor, a smart recorder that records images instead of coordinates, task health checks and failure attribution, a visual test framework (assertions, visual regression, HTML/JUnit reports) and a web console.
 Author: Equinox
 License-Expression: MIT
 Project-URL: Homepage, https://github.com/Equinox/PyClickerRPA
@@ -66,6 +66,7 @@ pip install "PyClickerRPA[web]"   # FastAPI + uvicorn — web console
 autoclicker                          # desktop GUI (flow editor / list editor / test tab)
 autoclicker-run task.json --window "Notepad"   # headless run against a window
 autoclicker-run task.json --adb                # run against an Android device (adb)
+autoclicker-lint task.json                     # health-check a task (exit code = error count)
 autoclicker-testkit suite.json --report out.html --junit out.xml   # run a test suite
 autoclicker-web --suites-dir examples          # web console at http://127.0.0.1:8000
 ```
@@ -82,7 +83,7 @@ autoclicker-web --suites-dir examples          # web console at http://127.0.0.1
 - **Smart wait**: `wait_stable` waits until the screen (or an ROI) stops
   changing — replaces guessed `sleep`s (fast when ready, patient when slow).
 - **~30+ step types**: click image/text/position, click-all, relative/offset
-  clicks, wait / random / wait-stable, drag / long-press / pinch / scroll,
+  clicks, wait / random / wait-stable, drag / **drag-from-image** / long-press / pinch / scroll,
   key / type / hotkey, loop / goto / while / do-until, if image/text/color/
   count/var with **true/false branching** (if-else), set-var, read-text→variable,
   activate-window, HTTP request, run-Python-script, call sub-task, groups, and a
@@ -93,12 +94,57 @@ autoclicker-web --suites-dir examples          # web console at http://127.0.0.1
 Drag-and-drop **node flow graph** (condition nodes have **true/false branch
 ports** for visual if-else; a terminal **stop** node ends the flow) and an
 interoperable **step list** with a full
-per-step dialog; an action **recorder** (global hooks), snippet library, task
+per-step dialog; snippet library, task
 packages (`.zip` with templates), on-preview coordinate/color picking, template
 crop, single-step test run; global hotkeys (F6 run/stop, ESC stop), scheduler,
 and an image/color **monitor/trigger** with tray icon; a **Test** tab to load and
 run visual test suites.
 
+### Smart recorder
+
+The action **recorder** (global hooks) doesn't just replay coordinates and
+sleeps — with **智能录制 / smart mode** on (default) it records what things *look
+like* instead of where they *were*:
+
+- **Clicks become image steps.** A patch is cropped around the click and grown
+  (48 → 192 px) until it is both textured enough and **unique on screen**, then
+  emitted as a `click_image` step — so the flow still works after the window
+  moves or the resolution changes. Identical patches are de-duplicated by
+  content hash.
+- **Drags become `drag_image`.** The drag's *start* is anchored to an image and
+  the *displacement* is stored, so start and end move together.
+- **Pauses become `wait_stable`.** A long pause is only converted if the
+  recorder actually **observed the screen settle** during it; on a permanently
+  animating screen it keeps the fixed wait (a `wait_stable` that never settles
+  would fail the run).
+
+Anything that can't be made robust falls back to the plain coordinate/fixed-wait
+step and says why in the log.
+
+## Diagnostics
+
+**Task health check** (`autoclicker-lint task.json`, or 诊断 → 任务体检 in the GUI)
+statically scans a task and separates *will definitely break* from *works but
+fragile*:
+
+- **errors** — missing template / sub-task file, image step with no template,
+  loop / goto / fail-jump target out of range, unbalanced groups. The GUI asks
+  for confirmation before running a task with errors; the CLI exit code is the
+  error count.
+- **warnings** — steps that depend on absolute coordinates, long fixed waits,
+  a match threshold low enough to hit the wrong thing, templates too small to be
+  unique. These are exactly the things the smart recorder now avoids, so the
+  check doubles as a "what should I re-record?" list.
+
+**Failure attribution.** A run captures a screenshot per step; the first
+successful run becomes the baseline timeline (`.timelines/<task>/`). When a later
+run fails, the frames are compared step by step and the report names the step
+where the screen **first diverged** from the successful run — which is usually
+*earlier* than the step that failed (step 7 can't find its button because a popup
+appeared at step 4). You get the diverging step, the per-step changed-pixel
+ratios, and a baseline|actual|heatmap image. If the screens match, it says so —
+that points at timing/flakiness rather than a UI change.
+
 ## Visual test framework (`autoclicker.testkit`)
 
 Turn automation into tests:

{pyclickerrpa-0.3.1 → pyclickerrpa-0.5.0}/PyClickerRPA.egg-info/SOURCES.txt

@@ -12,19 +12,23 @@ autoclicker/adb.py
 autoclicker/app.py
 autoclicker/capture.py
 autoclicker/clicker.py
+autoclicker/diagnose.py
 autoclicker/dpi.py
 autoclicker/expr.py
+autoclicker/lint.py
 autoclicker/matcher.py
 autoclicker/models.py
 autoclicker/ocr.py
 autoclicker/run.py
 autoclicker/runner.py
+autoclicker/templatize.py
 autoclicker/windows.py
 autoclicker/gui/__init__.py
 autoclicker/gui/flow_connection.py
 autoclicker/gui/flow_editor.py
 autoclicker/gui/flow_node.py
 autoclicker/gui/hotkeys.py
+autoclicker/gui/lint_dialog.py
 autoclicker/gui/main_window.py
 autoclicker/gui/monitor.py
 autoclicker/gui/preview_label.py
@@ -53,10 +57,15 @@ autoclicker/web/static/app.js
 autoclicker/web/static/index.html
 autoclicker/web/static/style.css
 tests/test_adb.py
+tests/test_diagnose.py
+tests/test_diagnose_gui.py
 tests/test_flow_branch.py
+tests/test_lint.py
 tests/test_matcher.py
 tests/test_models.py
+tests/test_recorder_gui.py
 tests/test_runner.py
+tests/test_templatize.py
 tests/test_testkit.py
 tests/test_testkit_gui.py
 tests/test_web.py

{pyclickerrpa-0.3.1 → pyclickerrpa-0.5.0}/PyClickerRPA.egg-info/entry_points.txt

@@ -1,4 +1,5 @@
 [console_scripts]
+autoclicker-lint = autoclicker.lint:main
 autoclicker-run = autoclicker.run:main
 autoclicker-testkit = autoclicker.testkit.__main__:main
 autoclicker-web = autoclicker.web.__main__:main

{pyclickerrpa-0.3.1 → pyclickerrpa-0.5.0}/README.md

@@ -28,6 +28,7 @@ pip install "PyClickerRPA[web]"   # FastAPI + uvicorn — web console
 autoclicker                          # desktop GUI (flow editor / list editor / test tab)
 autoclicker-run task.json --window "Notepad"   # headless run against a window
 autoclicker-run task.json --adb                # run against an Android device (adb)
+autoclicker-lint task.json                     # health-check a task (exit code = error count)
 autoclicker-testkit suite.json --report out.html --junit out.xml   # run a test suite
 autoclicker-web --suites-dir examples          # web console at http://127.0.0.1:8000
 ```
@@ -44,7 +45,7 @@ autoclicker-web --suites-dir examples          # web console at http://127.0.0.1
 - **Smart wait**: `wait_stable` waits until the screen (or an ROI) stops
   changing — replaces guessed `sleep`s (fast when ready, patient when slow).
 - **~30+ step types**: click image/text/position, click-all, relative/offset
-  clicks, wait / random / wait-stable, drag / long-press / pinch / scroll,
+  clicks, wait / random / wait-stable, drag / **drag-from-image** / long-press / pinch / scroll,
   key / type / hotkey, loop / goto / while / do-until, if image/text/color/
   count/var with **true/false branching** (if-else), set-var, read-text→variable,
   activate-window, HTTP request, run-Python-script, call sub-task, groups, and a
@@ -55,12 +56,57 @@ autoclicker-web --suites-dir examples          # web console at http://127.0.0.1
 Drag-and-drop **node flow graph** (condition nodes have **true/false branch
 ports** for visual if-else; a terminal **stop** node ends the flow) and an
 interoperable **step list** with a full
-per-step dialog; an action **recorder** (global hooks), snippet library, task
+per-step dialog; snippet library, task
 packages (`.zip` with templates), on-preview coordinate/color picking, template
 crop, single-step test run; global hotkeys (F6 run/stop, ESC stop), scheduler,
 and an image/color **monitor/trigger** with tray icon; a **Test** tab to load and
 run visual test suites.
 
+### Smart recorder
+
+The action **recorder** (global hooks) doesn't just replay coordinates and
+sleeps — with **智能录制 / smart mode** on (default) it records what things *look
+like* instead of where they *were*:
+
+- **Clicks become image steps.** A patch is cropped around the click and grown
+  (48 → 192 px) until it is both textured enough and **unique on screen**, then
+  emitted as a `click_image` step — so the flow still works after the window
+  moves or the resolution changes. Identical patches are de-duplicated by
+  content hash.
+- **Drags become `drag_image`.** The drag's *start* is anchored to an image and
+  the *displacement* is stored, so start and end move together.
+- **Pauses become `wait_stable`.** A long pause is only converted if the
+  recorder actually **observed the screen settle** during it; on a permanently
+  animating screen it keeps the fixed wait (a `wait_stable` that never settles
+  would fail the run).
+
+Anything that can't be made robust falls back to the plain coordinate/fixed-wait
+step and says why in the log.
+
+## Diagnostics
+
+**Task health check** (`autoclicker-lint task.json`, or 诊断 → 任务体检 in the GUI)
+statically scans a task and separates *will definitely break* from *works but
+fragile*:
+
+- **errors** — missing template / sub-task file, image step with no template,
+  loop / goto / fail-jump target out of range, unbalanced groups. The GUI asks
+  for confirmation before running a task with errors; the CLI exit code is the
+  error count.
+- **warnings** — steps that depend on absolute coordinates, long fixed waits,
+  a match threshold low enough to hit the wrong thing, templates too small to be
+  unique. These are exactly the things the smart recorder now avoids, so the
+  check doubles as a "what should I re-record?" list.
+
+**Failure attribution.** A run captures a screenshot per step; the first
+successful run becomes the baseline timeline (`.timelines/<task>/`). When a later
+run fails, the frames are compared step by step and the report names the step
+where the screen **first diverged** from the successful run — which is usually
+*earlier* than the step that failed (step 7 can't find its button because a popup
+appeared at step 4). You get the diverging step, the per-step changed-pixel
+ratios, and a baseline|actual|heatmap image. If the screens match, it says so —
+that points at timing/flakiness rather than a UI change.
+
 ## Visual test framework (`autoclicker.testkit`)
 
 Turn automation into tests:

pyclickerrpa-0.5.0/autoclicker/diagnose.py

@@ -0,0 +1,179 @@
+"""失败归因：拿上一次成功运行的逐步截图当基准，指出画面**第一次**偏离发生在哪一步。
+
+动机：失败的步骤往往不是出问题的步骤。第 7 步找不到图，真正的原因可能是第 4 步弹出了
+公告框。日志只会告诉你"第 7 步失败"，于是排查全靠人肉翻截图。
+
+timeline 帧结构沿用 TaskRunner 的 `{"index": int, "desc": str, "png": bytes}`。
+Qt-free。
+"""
+from __future__ import annotations
+
+import json
+import os
+import re
+from dataclasses import dataclass, field
+
+import cv2
+import numpy as np
+
+from autoclicker import matcher
+
+BASELINE_ROOT = ".timelines"
+DEFAULT_TOL = 0.02      # 变化像素比例超过这个就算"画面不一样了"
+INDEX_FILE = "index.json"
+
+
+@dataclass
+class StepDiff:
+    index: int
+    desc: str
+    ratio: float        # 变化像素比例；1.0 也可能表示尺寸不一致
+    note: str = ""
+
+    @property
+    def diverged(self) -> bool:
+        return self.ratio > DEFAULT_TOL
+
+
+@dataclass
+class Attribution:
+    failed_index: int
+    diverged_index: int | None          # 画面第一次偏离的步骤；None = 没查出偏离
+    diffs: list[StepDiff] = field(default_factory=list)
+    triptych_png: bytes | None = None   # 偏离那一步的 基准|实际|热力图
+    message: str = ""
+
+
+def safe_name(name: str) -> str:
+    s = re.sub(r'[<>:"/\\|?*\s]+', "_", (name or "task").strip())
+    return s[:60] or "task"
+
+
+def baseline_dir(task_name: str, root: str = BASELINE_ROOT) -> str:
+    return os.path.join(root, safe_name(task_name))
+
+
+# ─────────────────── 持久化 ───────────────────
+
+def save_timeline(timeline: list[dict], dirname: str) -> int:
+    os.makedirs(dirname, exist_ok=True)
+    meta = []
+    for pos, f in enumerate(timeline):
+        fname = f"frame_{pos:03d}_step_{int(f['index']):03d}.png"
+        with open(os.path.join(dirname, fname), "wb") as fh:
+            fh.write(f["png"])
+        meta.append({"file": fname, "index": int(f["index"]), "desc": f.get("desc", "")})
+    with open(os.path.join(dirname, INDEX_FILE), "w", encoding="utf-8") as fh:
+        json.dump(meta, fh, ensure_ascii=False, indent=2)
+    return len(meta)
+
+
+def load_timeline(dirname: str) -> list[dict]:
+    idx = os.path.join(dirname, INDEX_FILE)
+    if not os.path.isfile(idx):
+        return []
+    with open(idx, "r", encoding="utf-8") as fh:
+        meta = json.load(fh)
+    out = []
+    for m in meta:
+        p = os.path.join(dirname, m["file"])
+        if not os.path.isfile(p):
+            continue
+        with open(p, "rb") as fh:
+            out.append({"index": int(m["index"]), "desc": m.get("desc", ""), "png": fh.read()})
+    return out
+
+
+def has_baseline(dirname: str) -> bool:
+    return os.path.isfile(os.path.join(dirname, INDEX_FILE))
+
+
+def save_baseline_if_absent(timeline: list[dict], dirname: str) -> bool:
+    """只在还没有基准时写。沿用 visual.compare_region 的"无基准就创建"惯例。
+    返回是否真的写了。"""
+    if not timeline or has_baseline(dirname):
+        return False
+    save_timeline(timeline, dirname)
+    return True
+
+
+# ─────────────────── 比对 ───────────────────
+
+def _decode(png: bytes):
+    img = cv2.imdecode(np.frombuffer(png, dtype=np.uint8), cv2.IMREAD_COLOR)
+    return None if img is None or img.size == 0 else img
+
+
+def _by_step(timeline: list[dict]) -> dict[int, dict]:
+    """按步骤下标取**首帧**。循环会让同一步出现多次，比对时只认第一次进入那一帧。"""
+    out: dict[int, dict] = {}
+    for f in timeline:
+        out.setdefault(int(f["index"]), f)
+    return out
+
+
+def compare_timelines(baseline: list[dict], actual: list[dict],
+                      tol: float = DEFAULT_TOL) -> list[StepDiff]:
+    """按步骤下标对齐两条 timeline，逐步算变化像素比例。"""
+    base_map = _by_step(baseline)
+    diffs: list[StepDiff] = []
+    for f in _by_step(actual).values():
+        i = int(f["index"])
+        desc = f.get("desc", "")
+        b = base_map.get(i)
+        if b is None:
+            diffs.append(StepDiff(i, desc, 0.0, "基准里没有这一步(流程走了不同分支?)"))
+            continue
+        a_img, b_img = _decode(f["png"]), _decode(b["png"])
+        if a_img is None or b_img is None:
+            diffs.append(StepDiff(i, desc, 0.0, "截图无法解码"))
+            continue
+        if a_img.shape != b_img.shape:
+            diffs.append(StepDiff(i, desc, 1.0,
+                                  f"画面尺寸变了 基准{b_img.shape[1]}x{b_img.shape[0]} "
+                                  f"vs 实际{a_img.shape[1]}x{a_img.shape[0]}"))
+            continue
+        diffs.append(StepDiff(i, desc, matcher.diff_ratio(a_img, b_img)))
+    diffs.sort(key=lambda d: d.index)
+    return diffs
+
+
+def _triptych_for(baseline: list[dict], actual: list[dict], index: int) -> bytes | None:
+    from autoclicker.testkit.visual import heatmap, triptych
+    b = _by_step(baseline).get(index)
+    a = _by_step(actual).get(index)
+    if b is None or a is None:
+        return None
+    b_img, a_img = _decode(b["png"]), _decode(a["png"])
+    if b_img is None or a_img is None:
+        return None
+    if b_img.shape != a_img.shape:
+        return triptych(b_img, a_img, np.zeros_like(a_img))
+    per_pixel_max = cv2.absdiff(b_img, a_img).max(axis=2)
+    return triptych(b_img, a_img, heatmap(per_pixel_max))
+
+
+def attribute(baseline: list[dict], actual: list[dict], failed_index: int,
+              tol: float = DEFAULT_TOL) -> Attribution:
+    """归因。重点在 diverged_index：画面第一次和成功那次不一样是在哪一步。"""
+    if not baseline:
+        return Attribution(failed_index, None, [], None,
+                           "没有基准时间线可比对(成功跑一次后会自动建立)")
+    diffs = compare_timelines(baseline, actual, tol)
+    diverged = next((d for d in diffs if d.ratio > tol), None)
+    if diverged is None:
+        return Attribution(failed_index, None, diffs, None,
+                           f"第 {failed_index + 1} 步失败，但逐步画面和成功那次基本一致"
+                           f"(最大偏离 {max((d.ratio for d in diffs), default=0.0):.4f})；"
+                           f"可能是时序/随机性问题，而不是界面变了")
+    png = _triptych_for(baseline, actual, diverged.index)
+    if diverged.index < failed_index:
+        msg = (f"第 {failed_index + 1} 步失败，但画面从**第 {diverged.index + 1} 步**"
+               f"就开始和成功那次不一样了(偏离 {diverged.ratio:.4f})"
+               f"{' — ' + diverged.note if diverged.note else ''}。"
+               f"先查这一步: {diverged.desc}")
+    else:
+        msg = (f"第 {failed_index + 1} 步失败，画面偏离也正是从这一步开始"
+               f"(偏离 {diverged.ratio:.4f})"
+               f"{' — ' + diverged.note if diverged.note else ''}")
+    return Attribution(failed_index, diverged.index, diffs, png, msg)

pyclickerrpa-0.5.0/autoclicker/gui/lint_dialog.py

@@ -0,0 +1,53 @@
+"""任务体检结果弹窗：按严重程度着色，双击一条直接跳到对应步骤。"""
+from __future__ import annotations
+
+from PySide6.QtCore import Qt, Signal
+from PySide6.QtGui import QColor
+from PySide6.QtWidgets import (
+    QDialog, QLabel, QListWidget, QListWidgetItem, QPushButton, QVBoxLayout,
+)
+
+from autoclicker.lint import ERROR, INFO, WARN, Finding, counts
+
+_COLORS = {ERROR: QColor("#c62828"), WARN: QColor("#ef6c00"), INFO: QColor("#546e7a")}
+_ICONS = {ERROR: "✖", WARN: "▲", INFO: "·"}
+
+
+class LintDialog(QDialog):
+    stepActivated = Signal(int)      # 双击某条 → 该跳到的步骤下标
+
+    def __init__(self, findings: list[Finding], step_count: int, parent=None):
+        super().__init__(parent)
+        self.setWindowTitle("任务体检")
+        self.resize(720, 420)
+        lay = QVBoxLayout(self)
+
+        c = counts(findings)
+        if not findings:
+            summary = f"没查出问题({step_count} 步)。"
+        else:
+            summary = (f"共 {step_count} 步: {c[ERROR]} 个错误(会导致跑错), "
+                       f"{c[WARN]} 处脆弱(能跑但不稳), {c[INFO]} 条提示 —— 双击可跳到该步骤")
+        lay.addWidget(QLabel(summary))
+
+        self.list = QListWidget()
+        self.list.itemDoubleClicked.connect(self._on_double)
+        for level in (ERROR, WARN, INFO):
+            for f in findings:
+                if f.level != level:
+                    continue
+                where = "整个任务" if f.index < 0 else f"步骤 {f.index + 1}"
+                it = QListWidgetItem(f"{_ICONS[level]} {where}  {f.message}")
+                it.setForeground(_COLORS[level])
+                it.setData(Qt.UserRole, f.index)
+                self.list.addItem(it)
+        lay.addWidget(self.list, 1)
+
+        close = QPushButton("关闭")
+        close.clicked.connect(self.accept)
+        lay.addWidget(close)
+
+    def _on_double(self, item: QListWidgetItem):
+        index = item.data(Qt.UserRole)
+        if index is not None and index >= 0:
+            self.stepActivated.emit(int(index))