refactor(gui): 编排编辑窗口适配 Lua 引擎新接口

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

src/autoscript/ASEngine.py

@@ -0,0 +1,374 @@
+# -*- coding: utf-8 -*-
+"""
+Copyright (c) 2026 KenanZhu.
+All rights reserved.
+
+This software is provided "as is", without any warranty of any kind.
+You may use, modify, and distribute this file under the terms of the MIT License.
+See the LICENSE file for details.
+"""
+from datetime import (
+    date,
+    datetime,
+)
+
+from lupa import LuaRuntime as _LuaRuntime
+
+
+__all__ = ["execute", "addTargetVar", "resetEngine"]
+
+
+# Engine state
+_TARGET_VARS: dict[str, dict] = {}
+_lua = None
+
+# Built-in meta variable definitions (name / type / display-name)
+META_VARS = {
+    "CURRENT_DATE": {"name": "CURRENT_DATE", "type": "Date", "display": "当前日期"},
+    "CURRENT_TIME": {"name": "CURRENT_TIME", "type": "Time", "display": "当前时间"},
+}
+
+
+def _getLua(
+):
+    """
+        Return the sandboxed Lua runtime singleton.
+    """
+
+    global _lua
+    if _lua is None:
+        _lua = _LuaRuntime(unpack_returned_tuples = True)
+        _sandbox(_lua)
+        _registerHelpers(_lua)
+    return _lua
+
+
+def _sandbox(
+    lua,
+) -> None:
+    """
+        Remove dangerous Lua globals while keeping os.date / os.time for date-time helpers.
+    """
+
+    lua.execute("""
+        io = nil
+        require = nil
+        dofile = nil
+        loadfile = nil
+        load = nil
+        package = nil
+        rawget = nil
+        rawset = nil
+        rawequal = nil
+        getfenv = nil
+        setfenv = nil
+        debug = nil
+        -- selectively disable dangerous os functions, keep date / time
+        if os then
+            os.execute = nil
+            os.exit = nil
+            os.getenv = nil
+            os.remove = nil
+            os.rename = nil
+            os.tmpname = nil
+            os.setlocale = nil
+        end
+    """)
+
+
+def _registerHelpers(
+    lua,
+) -> None:
+    """
+        Inject Date / Time helpers as pure Lua functions.
+
+        Date values are os.time timestamps (seconds since epoch).
+        Time values are minutes since midnight (0-1439).
+
+        This keeps Date / Time as native Lua numbers during script execution,
+        enabling type-safe arithmetic (+, -) and comparisons (<, <=, ==, ~=).
+    """
+
+    lua.execute("""
+        function date(y, m, d)
+            return os.time({year = y, month = m, day = d})
+        end
+
+        function time(h, m)
+            return h * 60 + m
+        end
+
+        function CURRENT_DATE()
+            local now = os.date("*t")
+            return os.time({year = now.year, month = now.month, day = now.day})
+        end
+
+        function CURRENT_TIME()
+            local now = os.date("*t")
+            return now.hour * 60 + now.min
+        end
+
+        function date_add(date_val, n)
+            return date_val + n * 86400
+        end
+
+        function time_add(time_val, n)
+            return (time_val + n * 60) % 1440
+        end
+
+        -- push helpers: string -> native type
+        function _to_date(iso_str)
+            local y, m, d = iso_str:match("(%d+)-(%d+)-(%d+)")
+            return os.time({year = y, month = m, day = d})
+        end
+
+        function _to_time(hm_str)
+            local h, m = hm_str:match("(%d+):(%d+)")
+            return h * 60 + m
+        end
+
+        -- pull helpers: native type -> string
+        function _from_date(ts)
+            return os.date("%Y-%m-%d", ts)
+        end
+
+        function _from_time(m)
+            return string.format("%02d:%02d", math.floor(m / 60), m % 60)
+        end
+    """)
+
+
+def _navigatePath(
+    data: dict,
+    key_path: list,
+    default = None,
+):
+    """
+        Walk *key_path* into *data* and return the value at the leaf.
+    """
+
+    d = data
+    for key in key_path[:-1]:
+        d = d.get(key, {})
+        if not isinstance(d, dict):
+            return default
+    return d.get(key_path[-1], default)
+
+
+def _assignPath(
+    data: dict,
+    key_path: list,
+    value,
+) -> None:
+    """
+        Walk *key_path* into *data* and set *value* at the leaf.
+    """
+
+    d = data
+    for key in key_path[:-1]:
+        d = d.setdefault(key, {})
+    d[key_path[-1]] = value
+
+
+def _checkType(
+    var_name: str,
+    var_type: str,
+    value,
+) -> None:
+    """
+        Validate that *value* matches the declared variable type.
+
+        Date / Time values arrive as ISO / HH:MM strings (already converted
+        from Lua native types during the pull phase).
+        Int / Float / Boolean / String check Python type identity.
+        Int -> Float widening is allowed.
+    """
+
+    if var_type == "Date":
+        if not isinstance(value, str):
+            raise ValueError(
+                f"Date 类型变量 '{var_name}' 只能接受日期字符串，"
+                f"不能接受 {type(value).__name__} 类型"
+            )
+        date.fromisoformat(value)
+        return
+    if var_type == "Time":
+        if not isinstance(value, str):
+            raise ValueError(
+                f"Time 类型变量 '{var_name}' 只能接受时间字符串，"
+                f"不能接受 {type(value).__name__} 类型"
+            )
+        datetime.strptime(value, "%H:%M")
+        return
+    if var_type == "Int":
+        if isinstance(value, bool):
+            raise ValueError(
+                f"Int 类型变量 '{var_name}' 不能接受 Boolean 类型的值"
+            )
+        if not isinstance(value, int) and not (isinstance(value, float) and value == int(value)):
+            raise ValueError(
+                f"Int 类型变量 '{var_name}' 不能接受 {type(value).__name__} 类型的值"
+            )
+        return
+    if var_type == "Float":
+        if isinstance(value, bool):
+            raise ValueError(
+                f"Float 类型变量 '{var_name}' 不能接受 Boolean 类型的值"
+            )
+        if not isinstance(value, (int, float)):
+            raise ValueError(
+                f"Float 类型变量 '{var_name}' 不能接受 {type(value).__name__} 类型的值"
+            )
+        return
+    if var_type == "Boolean":
+        if not isinstance(value, bool):
+            raise ValueError(
+                f"Boolean 类型变量 '{var_name}' 不能接受 {type(value).__name__} 类型的值"
+            )
+        return
+    if var_type == "String":
+        if not isinstance(value, str):
+            raise ValueError(
+                f"String 类型变量 '{var_name}' 不能接受 {type(value).__name__} 类型的值"
+            )
+        return
+
+
+def addTargetVar(
+    name: str,
+    var_type: str,
+    key_path: list,
+    display_name: str = None,
+) -> None:
+    """
+        Register a new target variable bound to a path in the application data dict.
+
+        Args:
+            name (str): The canonical variable name (e.g. "RESERVE_DATE").
+            var_type (str): "Int" | "Float" | "Boolean" | "Date" | "Time" | "String".
+            key_path (list): Nested path into target_data, e.g. ["reserve_info", "date"].
+            display_name (str): Optional Chinese alias (unused by the engine).
+    """
+
+    upper_name = name.upper().strip()
+    _TARGET_VARS[upper_name] = {
+        "type": var_type,
+        "key_path": key_path,
+    }
+
+
+def resetEngine(
+) -> None:
+    """
+        Reset the engine to its initial state: clear all target variables
+        and release the Lua runtime.
+    """
+    global _TARGET_VARS, _lua
+    _TARGET_VARS = {}
+    _lua = None
+
+
+def _push(
+    target_data: dict,
+) -> None:
+    """
+        Push target_data values into Lua globals.
+        Date / Time strings are converted to native Lua types (timestamp / minutes).
+    """
+
+    lua = _getLua()
+    g = lua.globals()
+    _toDate = g["_to_date"]
+    _toTime = g["_to_time"]
+
+    for var_name, info in _TARGET_VARS.items():
+        key_path = info["key_path"]
+        vt = info["type"]
+        raw = _navigatePath(target_data, key_path)
+
+        if vt == "Date":
+            if raw and isinstance(raw, str):
+                try:
+                    date.fromisoformat(raw.strip())
+                except (ValueError, AttributeError):
+                    raw = "2099-01-01"
+            else:
+                raw = "2099-01-01"
+            g[var_name] = _toDate(raw)
+        elif vt == "Time":
+            if raw and isinstance(raw, str):
+                try:
+                    datetime.strptime(raw.strip(), "%H:%M")
+                except (ValueError, AttributeError):
+                    raw = "00:00"
+            else:
+                raw = "00:00"
+            g[var_name] = _toTime(raw)
+        else:
+            if raw is None:
+                raw = "" if vt == "String" else 0 if vt == "Int" else 0.0 if vt == "Float" else False
+            g[var_name] = raw
+
+
+def _pull(
+    target_data: dict,
+) -> None:
+    """
+        Pull Lua global values back into target_data.
+        Date / Time native types are converted back to ISO / HH:MM strings.
+    """
+
+    lua = _getLua()
+    g = lua.globals()
+    _fromDate = g["_from_date"]
+    _fromTime = g["_from_time"]
+
+    for var_name, info in _TARGET_VARS.items():
+        try:
+            lua_val = g[var_name]
+        except (KeyError, AttributeError):
+            continue
+        vt = info["type"]
+        if vt == "Date":
+            lua_val = _fromDate(lua_val)
+        elif vt == "Time":
+            lua_val = _fromTime(lua_val)
+        elif vt == "Float" and isinstance(lua_val, int) and not isinstance(lua_val, bool):
+            lua_val = float(lua_val)
+        _checkType(var_name, vt, lua_val)
+        _assignPath(target_data, info["key_path"], lua_val)
+
+
+def execute(
+    script_text: str,
+    target_data: dict,
+) -> None:
+    """
+        Execute an AutoScript (Lua) on the given target data.
+
+        The script runs in a sandboxed Lua environment with target variables
+        exposed as globals.  The following helpers are available as Lua functions:
+
+          date(y, m, d)         -> timestamp (os.time seconds)
+          time(h, m)            -> minutes since midnight (0-1439)
+          CURRENT_DATE()        -> today's timestamp
+          CURRENT_TIME()        -> current minutes since midnight
+          date_add(ts, n)       -> ts + n * 86400
+          time_add(m, n)        -> (m + n * 60) % 1440
+
+        Date and Time values are native Lua numbers during execution.
+        Arithmetic (+, -) and comparisons (<, <=, ==, ~=, >, >=) work
+        with strong type safety — no implicit string coercion.
+
+        Raises:
+            ValueError: On Lua compilation/runtime errors or type mismatches.
+    """
+
+    if not script_text or not script_text.strip():
+        return
+    _push(target_data)
+    try:
+        _getLua().execute(script_text)
+        _pull(target_data)
+    except Exception as e:
+        raise ValueError(f"AutoScript 执行错误: {e}")

src/autoscript/__init__.py

@@ -0,0 +1,82 @@
+# -*- coding: utf-8 -*-
+"""
+Copyright (c) 2026 KenanZhu.
+All rights reserved.
+
+This software is provided "as is", without any warranty of any kind.
+You may use, modify, and distribute this file under the terms of the MIT License.
+See the LICENSE file for details.
+"""
+from autoscript.ASEngine import (
+    execute,
+    addTargetVar,
+    resetEngine,
+    META_VARS,
+)
+
+
+__all__ = [
+    "execute",
+    "addTargetVar",
+    "resetEngine",
+    "registerDefaultTargetVars",
+    "buildMockTargetData",
+    "META_VARS",
+    "ALL_VARIABLES",
+    "_TARGET_VAR_DEFS",
+    "_MOCK_TYPE_VALUES",
+]
+
+
+# Key paths into target_data dict for each target variable.
+# (name, type, key_path, display_name)
+_TARGET_VAR_DEFS = [
+    ("USERNAME",           "String",["username"],                           "用户名"),
+    ("USER_ENABLE",        "Boolean",["enabled"],                           "用户启用"),
+    ("RESERVE_DATE",       "Date",  ["reserve_info", "date"],               "预约日期"),
+    ("RESERVE_BEGIN_TIME", "Time",  ["reserve_info", "begin_time", "time"], "预约开始时间"),
+    ("RESERVE_END_TIME",   "Time",  ["reserve_info", "end_time",   "time"], "预约结束时间"),
+]
+
+# All variables (display_name -> (name, type)), derived from target vars + meta vars.
+ALL_VARIABLES = {
+    display_name: (name, var_type)
+    for name, var_type, _, display_name in _TARGET_VAR_DEFS
+} | {
+    v["display"]: (v["name"], v["type"])
+    for v in META_VARS.values()
+}
+_MOCK_TYPE_VALUES = {
+    "String": "__mock__",
+    "Boolean": True,
+    "Date": "2099-01-01",
+    "Time": "00:00",
+    "Int": 0,
+    "Float": 0.0,
+}
+
+
+def buildMockTargetData(
+) -> dict:
+    """
+        Build a target_data dict filled with type-appropriate mock values
+        for all registered target variables.
+    """
+    data = {}
+    for _, var_type, key_path, _ in _TARGET_VAR_DEFS:
+        d = data
+        for key in key_path[:-1]:
+            d = d.setdefault(key, {})
+        d[key_path[-1]] = _MOCK_TYPE_VALUES.get(var_type, "")
+    return data
+
+
+def registerDefaultTargetVars(
+) -> None:
+    """
+        Register all built-in target variables with the engine.
+        This must be called before any script execution.
+        Calling multiple times is idempotent (re-registers same keys).
+    """
+    for name, var_type, key_path, display_name in _TARGET_VAR_DEFS:
+        addTargetVar(name, var_type, key_path, display_name)

src/gui/ALAutoScriptEditDialog.py

@@ -0,0 +1,650 @@
+# -*- coding: utf-8 -*-
+"""
+Copyright (c) 2026 KenanZhu.
+All rights reserved.
+
+This software is provided "as is", without any warranty of any kind.
+You may use, modify, and distribute this file under the terms of the MIT License.
+See the LICENSE file for details.
+"""
+from copy import deepcopy
+
+from PySide6.QtCore import QDate, Qt, QTime, QTimer, Slot
+from PySide6.QtGui import (
+    QColor,
+    QFont,
+    QSyntaxHighlighter,
+    QTextCharFormat,
+)
+from PySide6.QtWidgets import (
+    QApplication,
+    QComboBox,
+    QDateEdit,
+    QDialog,
+    QDialogButtonBox,
+    QDoubleSpinBox,
+    QFormLayout,
+    QFrame,
+    QGridLayout,
+    QGroupBox,
+    QHBoxLayout,
+    QHeaderView,
+    QLabel,
+    QLineEdit,
+    QMessageBox,
+    QPlainTextEdit,
+    QPushButton,
+    QSpinBox,
+    QSplitter,
+    QStyle,
+    QTabWidget,
+    QTableWidget,
+    QTableWidgetItem,
+    QTimeEdit,
+    QVBoxLayout,
+    QWidget,
+)
+
+from autoscript import (
+    ALL_VARIABLES,
+    _MOCK_TYPE_VALUES,
+    _TARGET_VAR_DEFS,
+    execute,
+    registerDefaultTargetVars,
+)
+
+
+class ALScriptHighlighter(QSyntaxHighlighter):
+    """
+        Syntax highlighter for Lua-based AutoScript.
+    """
+
+    def __init__(
+        self,
+        parent = None
+    ):
+
+        super().__init__(parent)
+        self._rules = []
+
+        keywordFmt = QTextCharFormat()
+        keywordFmt.setForeground(QColor("#569CD6"))
+        keywordFmt.setFontWeight(QFont.Weight.Bold)
+        for kw in [
+            "if", "elseif", "else", "end", "then",
+            "and", "or", "not",
+            "local", "function", "return", "nil",
+        ]:
+            self._rules.append((r"\b" + kw + r"\b", keywordFmt))
+        boolFmt = QTextCharFormat()
+        boolFmt.setForeground(QColor("#4FC1FF"))
+        boolFmt.setFontWeight(QFont.Weight.Bold)
+        self._rules.append((r"\btrue\b", boolFmt))
+        self._rules.append((r"\bfalse\b", boolFmt))
+        cmpFmt = QTextCharFormat()
+        cmpFmt.setForeground(QColor("#C586C0"))
+        cmpFmt.setFontWeight(QFont.Weight.Normal)
+        for op in [r"==", r"~=", r">=", r"<=", r">", r"<"]:
+            self._rules.append((op, cmpFmt))
+        arithFmt = QTextCharFormat()
+        arithFmt.setForeground(QColor("#C586C0"))
+        arithFmt.setFontWeight(QFont.Weight.Normal)
+        for op in [r"\+", r"-", r"\*", r"/", r"\.\."]:
+            self._rules.append((op, arithFmt))
+        funcFmt = QTextCharFormat()
+        funcFmt.setForeground(QColor("#DCDCAA"))
+        funcFmt.setFontWeight(QFont.Weight.Normal)
+        for fn in ["CURRENT_DATE", "CURRENT_TIME", "date_add", "time_add"]:
+            self._rules.append((r"\b" + fn + r"\b", funcFmt))
+        varFmt = QTextCharFormat()
+        varFmt.setForeground(QColor("#9CDCFE"))
+        varFmt.setFontWeight(QFont.Weight.Normal)
+        var_names = [name for _, (name, _) in ALL_VARIABLES.items()]
+        for var in var_names:
+            self._rules.append((r"\b" + var + r"\b", varFmt))
+        strFmt = QTextCharFormat()
+        strFmt.setForeground(QColor("#CE9178"))
+        strFmt.setFontWeight(QFont.Weight.Normal)
+        self._rules.append((r'"[^"]*"', strFmt))
+        self._rules.append((r"'[^']*'", strFmt))
+        numFmt = QTextCharFormat()
+        numFmt.setForeground(QColor("#B5CEA8"))
+        numFmt.setFontWeight(QFont.Weight.Normal)
+        self._rules.append((r"\b\d+(?:\.\d+)?\b", numFmt))
+        commentFmt = QTextCharFormat()
+        commentFmt.setForeground(QColor("#6A9955"))
+        commentFmt.setFontItalic(True)
+        self._rules.append((r"--[^\n]*", commentFmt))
+
+
+    def highlightBlock(
+        self,
+        text
+    ):
+
+        import re
+        for pattern, fmt in self._rules:
+            for match in re.finditer(pattern, text, re.IGNORECASE):
+                start = match.start()
+                length = match.end() - match.start()
+                self.setFormat(start, length, fmt)
+
+
+class _DebugResultDialog(QDialog):
+
+    def __init__(
+        self,
+        changes: list,
+        parent = None
+    ):
+
+        super().__init__(parent)
+        self.setWindowTitle("调试运行结果 - AutoLibrary")
+        self.setMinimumSize(600, 200)
+        layout = QVBoxLayout(self)
+        table = QTableWidget(len(changes), 3)
+        table.setHorizontalHeaderLabels(["目标变量", "原始数据", "运行后数据"])
+        table.horizontalHeader().setStretchLastSection(True)
+        table.horizontalHeader().setSectionResizeMode(QHeaderView.Stretch)
+        table.setEditTriggers(QTableWidget.EditTrigger.NoEditTriggers)
+        for row, (display_name, name, var_type, before_val, after_val) in enumerate(changes):
+            label = f"{display_name}: {name}({var_type})"
+            table.setItem(row, 0, QTableWidgetItem(label))
+            table.setItem(row, 1, QTableWidgetItem(str(before_val)))
+            table.setItem(row, 2, QTableWidgetItem(str(after_val)))
+        layout.addWidget(table)
+        btnBox = QDialogButtonBox(QDialogButtonBox.StandardButton.Ok)
+        btnBox.button(QDialogButtonBox.StandardButton.Ok).setText("确定")
+        btnBox.accepted.connect(self.accept)
+        layout.addWidget(btnBox)
+
+
+class ALAutoScriptEditDialog(QDialog):
+
+    def __init__(
+        self,
+        parent = None,
+        script: str = "",
+        mockData: dict = None
+    ):
+
+        super().__init__(parent)
+        self._fontSize = 19
+        self._mockWidgets = {}
+
+        self.setupUi()
+        self.connectSignals()
+        self.textEdit.setPlainText(script)
+        self._highlighter = ALScriptHighlighter(
+            self.textEdit.document()
+        )
+        if mockData:
+            self.setMockData(mockData)
+
+
+    def setupUi(
+        self
+    ):
+
+        self.setWindowTitle("AutoScript 编辑 - AutoLibrary")
+        self.setMinimumSize(660, 600)
+        layout = QVBoxLayout(self)
+        layout.setSpacing(3)
+        layout.setContentsMargins(3, 3, 3, 3)
+        toolbarLayout = QHBoxLayout()
+        self.zoomInBtn = QPushButton("＋")
+        self.zoomInBtn.setFixedSize(25, 25)
+        self.zoomOutBtn = QPushButton("－")
+        self.zoomOutBtn.setFixedSize(25, 25)
+        self.zoomResetBtn = QPushButton(
+            QApplication.style().standardIcon(
+                QStyle.StandardPixmap.SP_BrowserReload
+            ), ""
+        )
+        self.zoomResetBtn.setFixedSize(25, 25)
+        self.zoomResetBtn.setToolTip("重置缩放")
+        self.zoomLabel = QLabel(f"{self._fontSize}px")
+        self.zoomLabel.setFixedHeight(25)
+        self.orchBtn = QPushButton("编排")
+        self.orchBtn.setFixedHeight(25)
+        self.orchBtn.setToolTip("可视化生成 AutoScript 代码并插入到光标位置")
+        toolbarLayout.addWidget(self.orchBtn)
+        self.debugBtn = QPushButton("▶ 调试运行")
+        self.debugBtn.setFixedHeight(25)
+        self.debugBtn.setToolTip("使用右侧模拟数据执行脚本，查看目标变量变化")
+        toolbarLayout.addWidget(self.debugBtn)
+        sep = QFrame()
+        sep.setFrameShape(QFrame.Shape.VLine)
+        sep.setFrameShadow(QFrame.Shadow.Sunken)
+        sep.setFixedWidth(1)
+        toolbarLayout.addWidget(sep)
+        toolbarLayout.addWidget(self.zoomInBtn)
+        toolbarLayout.addWidget(self.zoomOutBtn)
+        toolbarLayout.addWidget(self.zoomResetBtn)
+        toolbarLayout.addWidget(self.zoomLabel)
+        toolbarLayout.addStretch()
+        self.copyBtn = QPushButton(
+            QApplication.style().standardIcon(
+                QStyle.StandardPixmap.SP_FileDialogDetailedView
+            ), ""
+        )
+        self.copyBtn.setFixedSize(25, 25)
+        self.copyBtn.setToolTip("复制脚本")
+        toolbarLayout.addWidget(self.copyBtn)
+        layout.addLayout(toolbarLayout)
+        self.textEdit = QPlainTextEdit(self)
+        self.textEdit.setLineWrapMode(
+            QPlainTextEdit.LineWrapMode.NoWrap
+        )
+        self.textEdit.setStyleSheet(
+            "QPlainTextEdit {"
+            "  font-family: 'Courier New', 'Consolas', monospace;"
+           f"  font-size: {self._fontSize}px;"
+            "}"
+        )
+        layout.addWidget(self.textEdit)
+        self._createButtonPanel(layout)
+        self.btnBox = QDialogButtonBox(
+            QDialogButtonBox.StandardButton.Ok |
+            QDialogButtonBox.StandardButton.Cancel
+        )
+        self.btnBox.button(QDialogButtonBox.StandardButton.Ok).setText("确定")
+        self.btnBox.button(QDialogButtonBox.StandardButton.Cancel).setText("取消")
+        layout.addWidget(self.btnBox)
+
+
+    def _createButtonPanel(
+        self,
+        parent_layout
+    ):
+
+        splitter = QSplitter(Qt.Orientation.Horizontal)
+        tabWidget = QTabWidget()
+        tabWidget.setMaximumHeight(150)
+        basicWidget = QWidget()
+        basicLayout = QGridLayout(basicWidget)
+        basicLayout.setSpacing(4)
+        basicLayout.setContentsMargins(4, 4, 4, 4)
+        basicLayout.setAlignment(Qt.AlignLeft | Qt.AlignTop)
+        controlButtons = [
+            ("if", "if  then\n    \nend"),
+            ("elseif", "elseif  then\n    "),
+            ("else", "else"),
+            ("end", "end"),
+            ("-- pass", "-- pass"),
+        ]
+        self._addButtonsToGrid(basicLayout, controlButtons, 0, 0, 5)
+        assignButtons = [
+            ("=", " = "),
+        ]
+        self._addButtonsToGrid(basicLayout, assignButtons, 0, 5, 1)
+        tabWidget.addTab(basicWidget, "基本语法")
+        operatorWidget = QWidget()
+        operatorLayout = QGridLayout(operatorWidget)
+        operatorLayout.setSpacing(4)
+        operatorLayout.setContentsMargins(4, 4, 4, 4)
+        operatorLayout.setAlignment(Qt.AlignLeft | Qt.AlignTop)
+        arithmeticButtons = [
+            ("+", " + "),
+            ("-", " - "),
+        ]
+        self._addButtonsToGrid(operatorLayout, arithmeticButtons, 0, 0, 2)
+        compareButtons = [
+            ("==", " == "),
+            ("~=", " ~= "),
+            (">", " > "),
+            ("<", " < "),
+            (">=", " >= "),
+            ("<=", " <= "),
+        ]
+        self._addButtonsToGrid(operatorLayout, compareButtons, 1, 0, 6)
+        logic_buttons = [
+            ("and", " and "),
+            ("or", " or "),
+        ]
+        self._addButtonsToGrid(operatorLayout, logic_buttons, 2, 0, 2)
+        tabWidget.addTab(operatorWidget, "运算符")
+        literalWidget = QWidget()
+        literalLayout = QGridLayout(literalWidget)
+        literalLayout.setSpacing(4)
+        literalLayout.setContentsMargins(4, 4, 4, 4)
+        literalLayout.setAlignment(Qt.AlignLeft | Qt.AlignTop)
+        bool_buttons = [
+            ("true", "true"),
+            ("false", "false"),
+        ]
+        self._addButtonsToGrid(literalLayout, bool_buttons, 0, 0, 2)
+        dateTimeButtons = [
+            ("日期", '"2099-01-01"'),
+            ("时间", '"00:00"'),
+        ]
+        self._addButtonsToGrid(literalLayout, dateTimeButtons, 1, 0, 2)
+        hintButtons = [
+            ("字符串", '"请输入文本"'),
+            ("数字", "123"),
+            ("注释", "-- 请输入注释"),
+        ]
+        self._addButtonsToGrid(literalLayout, hintButtons, 2, 0, 3)
+        tabWidget.addTab(literalWidget, "字面量")
+        varWidget = QWidget()
+        varLayout = QGridLayout(varWidget)
+        varLayout.setSpacing(4)
+        varLayout.setContentsMargins(4, 4, 4, 4)
+        varLayout.setAlignment(Qt.AlignLeft | Qt.AlignTop)
+        varButtons = [
+            (display_name, name) for display_name, (name, _) in ALL_VARIABLES.items()
+        ]
+
+        self._addButtonsToGrid(varLayout, varButtons, 0, 0, 5)
+        tabWidget.addTab(varWidget, "变量")
+        mockPanel = self._createMockPanel()
+        mockPanel.setMinimumWidth(260)
+        splitter.addWidget(tabWidget)
+        splitter.addWidget(mockPanel)
+        splitter.setStretchFactor(0, 1)
+        splitter.setStretchFactor(1, 0)
+        splitter.setSizes([660, 400])
+        parent_layout.addWidget(splitter)
+
+
+    def _addButtonsToGrid(
+        self,
+        grid_layout,
+        buttons,
+        start_row,
+        start_col,
+        max_columns
+    ):
+
+        col = start_col
+        row = start_row
+
+        for btn_text, template in buttons:
+            btn = QPushButton(btn_text)
+            btn.setProperty("template", template)
+            btn.clicked.connect(self._insertTemplate)
+            btn.setFixedWidth(100)
+            btn.setFixedHeight(25)
+            btn.setToolTip(f"插入: {template}")
+            grid_layout.addWidget(btn, row, col)
+
+            col += 1
+            if col >= start_col + max_columns:
+                col = start_col
+                row += 1
+
+    @Slot()
+    def _insertTemplate(
+        self
+    ):
+
+        btn = self.sender()
+        if not isinstance(btn, QPushButton):
+            return
+        template = btn.property("template")
+        if not template:
+            return
+        cursor = self.textEdit.textCursor()
+        cursor.insertText(template)
+
+
+    def _createMockPanel(
+        self
+    ) -> QGroupBox:
+
+        group = QGroupBox("模拟目标数据")
+        form = QFormLayout(group)
+        form.setSpacing(4)
+        form.setContentsMargins(5, 10, 5, 5)
+        self._mockWidgets = {}
+        for name, var_type, key_path, display_name in _TARGET_VAR_DEFS:
+            default = _MOCK_TYPE_VALUES.get(var_type, "")
+            widget = self._makeMockInput(var_type, default)
+            label = QLabel(f"{display_name}: {name}({var_type})")
+            form.addRow(label, widget)
+            self._mockWidgets[name] = (widget, var_type, key_path)
+        return group
+
+
+    def _makeMockInput(
+        self,
+        var_type: str,
+        default
+    ) -> QWidget:
+
+        if var_type == "String":
+            w = QLineEdit()
+            w.setText(str(default))
+            return w
+        if var_type == "Boolean":
+            w = QComboBox()
+            w.addItems(["是", "否"])
+            w.setCurrentIndex(0 if default else 1)
+            return w
+        if var_type == "Date":
+            w = QDateEdit()
+            w.setCalendarPopup(True)
+            w.setDisplayFormat("yyyy-MM-dd")
+            w.setDate(QDate.fromString(str(default), "yyyy-MM-dd"))
+            return w
+        if var_type == "Time":
+            w = QTimeEdit()
+            w.setDisplayFormat("HH:mm")
+            w.setTime(QTime.fromString(str(default), "HH:mm"))
+            return w
+        if var_type == "Int":
+            w = QSpinBox()
+            w.setMinimum(-999999)
+            w.setMaximum(999999)
+            w.setValue(int(default) if default else 0)
+            return w
+        if var_type == "Float":
+            w = QDoubleSpinBox()
+            w.setMinimum(-999999.0)
+            w.setMaximum(999999.0)
+            w.setDecimals(2)
+            w.setValue(float(default) if default else 0.0)
+            return w
+        w = QLineEdit()
+        w.setText(str(default))
+        return w
+
+
+    def getMockData(
+        self
+    ) -> dict:
+
+        data = {}
+        for name, var_type, key_path, display_name in _TARGET_VAR_DEFS:
+            widget, _, _ = self._mockWidgets[name]
+            value = self._getMockValue(widget, var_type)
+            d = data
+            for key in key_path[:-1]:
+                d = d.setdefault(key, {})
+            d[key_path[-1]] = value
+        return data
+
+
+    def setMockData(
+        self,
+        data: dict
+    ):
+
+        if not data:
+            return
+        for name, var_type, key_path, display_name in _TARGET_VAR_DEFS:
+            d = data
+            try:
+                for key in key_path:
+                    d = d[key]
+            except (KeyError, TypeError):
+                continue
+            widget, _, _ = self._mockWidgets[name]
+            self._setMockValue(widget, var_type, d)
+
+
+    def _getMockValue(
+        self,
+        widget: QWidget,
+        var_type: str
+    ):
+
+        if var_type == "Boolean":
+            return widget.currentIndex() == 0
+        if var_type == "Date":
+            return widget.date().toString("yyyy-MM-dd")
+        if var_type == "Time":
+            return widget.time().toString("HH:mm")
+        if var_type == "Int":
+            return widget.value()
+        if var_type == "Float":
+            return widget.value()
+        return widget.text()
+
+
+    def _setMockValue(
+        self,
+        widget: QWidget,
+        var_type: str,
+        value
+    ):
+
+        if var_type == "Boolean":
+            widget.setCurrentIndex(0 if value else 1)
+        elif var_type == "Date":
+            widget.setDate(QDate.fromString(str(value), "yyyy-MM-dd"))
+        elif var_type == "Time":
+            widget.setTime(QTime.fromString(str(value), "HH:mm"))
+        elif var_type == "Int":
+            widget.setValue(int(value))
+        elif var_type == "Float":
+            widget.setValue(float(value))
+        else:
+            widget.setText(str(value))
+
+
+    @Slot()
+    def onDebugRun(
+        self
+    ):
+
+        script = self.textEdit.toPlainText().strip()
+        if not script:
+            QMessageBox.warning(self, "提示", "脚本内容为空。")
+            return
+        target_data = self.getMockData()
+        before = deepcopy(target_data)
+        try:
+            registerDefaultTargetVars()
+            execute(script, target_data)
+        except ValueError as e:
+            QMessageBox.warning(self, "运行错误", str(e))
+            return
+        changes = []
+        for name, var_type, key_path, display_name in _TARGET_VAR_DEFS:
+            before_val = before
+            after_val = target_data
+            try:
+                for key in key_path:
+                    before_val = before_val[key]
+                    after_val = after_val[key]
+            except (KeyError, TypeError):
+                continue
+            if before_val != after_val:
+                changes.append((display_name, name, var_type, before_val, after_val))
+        if not changes:
+            QMessageBox.information(self, "调试运行", "目标变量未发生变化。")
+            return
+        dlg = _DebugResultDialog(changes, self)
+        dlg.exec()
+        dlg.deleteLater()
+
+
+    def connectSignals(
+        self
+    ):
+
+        self.btnBox.accepted.connect(self.accept)
+        self.btnBox.rejected.connect(self.reject)
+        self.orchBtn.clicked.connect(self.onOpenOrchDialog)
+        self.debugBtn.clicked.connect(self.onDebugRun)
+        self.zoomInBtn.clicked.connect(self.onZoomIn)
+        self.zoomOutBtn.clicked.connect(self.onZoomOut)
+        self.zoomResetBtn.clicked.connect(self.onZoomReset)
+        self.copyBtn.clicked.connect(self.onCopy)
+
+
+    def getScript(
+        self
+    ) -> str:
+
+        return self.textEdit.toPlainText()
+
+
+    def updateFontSize(
+        self
+    ):
+
+        font = self.textEdit.font()
+        font.setPointSize(self._fontSize)
+        self.textEdit.setFont(font)
+        self.textEdit.setStyleSheet(
+            "QPlainTextEdit {"
+            "  font-family: 'Courier New', 'Consolas', monospace;"
+            f"  font-size: {self._fontSize}px;"
+            "}"
+        )
+        self.zoomLabel.setText(f"{self._fontSize}px")
+
+    @Slot()
+    def onZoomIn(
+        self
+    ):
+
+        self._fontSize = min(self._fontSize + 2, 40)
+        self.updateFontSize()
+
+    @Slot()
+    def onZoomOut(
+        self
+    ):
+
+        self._fontSize = max(self._fontSize - 2, 8)
+        self.updateFontSize()
+
+    @Slot()
+    def onZoomReset(
+        self
+    ):
+
+        self._fontSize = 13
+        self.updateFontSize()
+
+    @Slot()
+    def onCopy(
+        self
+    ):
+
+        clipboard = QApplication.clipboard()
+        clipboard.setText(self.textEdit.toPlainText())
+        original = self.copyBtn.text()
+        self.copyBtn.setText("已复制")
+        self.copyBtn.setEnabled(False)
+        QTimer.singleShot(2000, lambda: (
+            self.copyBtn.setText(original),
+            self.copyBtn.setEnabled(True)
+        ))
+
+    @Slot()
+    def onOpenOrchDialog(
+        self
+    ):
+
+        from gui.ALAutoScriptOrchDialog import ALAutoScriptOrchDialog
+        dlg = ALAutoScriptOrchDialog(self)
+        if dlg.exec() == QDialog.DialogCode.Accepted:
+            script = dlg.getScript()
+            if script:
+                cursor = self.textEdit.textCursor()
+                cursor.insertText(script)
+        dlg.deleteLater()

src/gui/ALAutoScriptOrchDialog.py

@@ -1,884 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-Copyright (c) 2026 KenanZhu.
-All rights reserved.
-
-This software is provided "as is", without any warranty of any kind.
-You may use, modify, and distribute this file under the terms of the MIT License.
-See the LICENSE file for details.
-"""
-
-from PySide6.QtCore import QTime, QDate, Slot
-from PySide6.QtWidgets import (
-    QDialog, QWidget, QVBoxLayout, QHBoxLayout, QLabel,
-    QComboBox, QPushButton, QScrollArea, QTimeEdit,
-    QDateEdit, QLineEdit, QSpinBox, QDoubleSpinBox,
-    QStackedWidget, QFrame, QDialogButtonBox,
-    QGroupBox, QSizePolicy
-)
-
-from utils.AutoScriptEngine import AutoScriptEngine
-
-
-VARIABLE_META = AutoScriptEngine.VARIABLE_META
-_VAR_COMBO_ITEMS = [
-    (display, varname, vartype)
-    for display, (varname, vartype) in VARIABLE_META.items()
-]
-_VAR_COMBO_ITEMS_SET = [
-    (display, varname, vartype)
-    for display, (varname, vartype) in VARIABLE_META.items()
-    if not varname.startswith("CURRENT_")
-]
-OP_ITEMS = [
-    ("等于", ".EQ."),
-    ("不等于", ".NEQ."),
-    ("大于", ".BGT."),
-    ("小于", ".BLT."),
-    ("大于等于", ".BGE."),
-    ("小于等于", ".BLE."),
-]
-
-
-def _makeVarCombo(
-) -> QComboBox:
-
-    cb = QComboBox()
-    for display, varname, vartype in _VAR_COMBO_ITEMS:
-        cb.addItem(display, (varname, vartype))
-    cb.setMinimumWidth(120)
-    cb.setFixedHeight(25)
-    return cb
-
-
-def _makeSetVarCombo(
-) -> QComboBox:
-
-    cb = QComboBox()
-    for display, varname, vartype in _VAR_COMBO_ITEMS_SET:
-        cb.addItem(display, (varname, vartype))
-    cb.setMinimumWidth(120)
-    cb.setFixedHeight(25)
-    return cb
-
-
-def _makeOpCombo(
-) -> QComboBox:
-
-    cb = QComboBox()
-    for display, op in OP_ITEMS:
-        cb.addItem(display, op)
-    cb.setMinimumWidth(80)
-    cb.setFixedHeight(25)
-    return cb
-
-
-def _makeValueWidget(
-    data_type: str
-) -> QWidget:
-
-    if data_type == "Time":
-        w = QTimeEdit()
-        w.setDisplayFormat("HH:mm")
-        w.setMinimumWidth(100)
-        w.setFixedHeight(25)
-    elif data_type == "Date":
-        w = QDateEdit()
-        w.setDisplayFormat("yyyy-MM-dd")
-        w.setCalendarPopup(True)
-        w.setMinimumWidth(130)
-        w.setFixedHeight(25)
-    elif data_type == "Integer":
-        w = QSpinBox()
-        w.setMinimum(-999999)
-        w.setMaximum(999999)
-        w.setMinimumWidth(100)
-        w.setFixedHeight(25)
-    elif data_type == "Float":
-        w = QDoubleSpinBox()
-        w.setMinimum(-999999)
-        w.setMaximum(999999)
-        w.setDecimals(2)
-        w.setMinimumWidth(100)
-        w.setFixedHeight(25)
-    elif data_type == "Boolean":
-        w = QComboBox()
-        w.addItem(".TRUE.", ".TRUE.")
-        w.addItem(".FALSE.", ".FALSE.")
-        w.setMinimumWidth(100)
-        w.setFixedHeight(25)
-    else:
-        w = QLineEdit()
-        w.setPlaceholderText("输入值")
-        w.setMinimumWidth(120)
-        w.setFixedHeight(25)
-    return w
-
-
-def _makeActionValueWidget(
-    data_type: str
-) -> QWidget:
-
-    if data_type == "Date":
-        w = QComboBox()
-        w.addItem("今天", "today")
-        w.addItem("明天", "tomorrow")
-        w.setFixedHeight(25)
-        w.setMinimumWidth(100)
-        w._is_date_action = True
-        return w
-
-    if data_type == "Time":
-        container = QWidget()
-        layout = QHBoxLayout(container)
-        layout.setContentsMargins(0, 0, 0, 0)
-        layout.setSpacing(2)
-        modeCombo = QComboBox()
-        modeCombo.addItem("固定时间", "fixed")
-        modeCombo.addItem("相对当前", "relative")
-        modeCombo.setFixedHeight(25)
-        stack = QStackedWidget()
-        timeEdit = QTimeEdit()
-        timeEdit.setDisplayFormat("HH:mm")
-        timeEdit.setFixedHeight(25)
-        spinBox = QSpinBox()
-        spinBox.setRange(0, 23)
-        spinBox.setSuffix("小时")
-        spinBox.setFixedHeight(25)
-        stack.addWidget(timeEdit)
-        stack.addWidget(spinBox)
-        modeCombo.currentIndexChanged.connect(
-            lambda i: stack.setCurrentIndex(i)
-        )
-        layout.addWidget(modeCombo)
-        layout.addWidget(stack)
-        container._modeCombo = modeCombo
-        container._timeEdit = timeEdit
-        container._spinBox = spinBox
-        container._isActionTime = True
-        return container
-
-    return _makeValueWidget(data_type)
-
-
-def _getValueFromWidget(
-    w: QWidget
-) -> str:
-
-    if getattr(w, '_isActionTime', False):
-        if w._modeCombo.currentData() == "fixed":
-            return w._timeEdit.time().toString("HH:mm")
-        else:
-            return f"+{w._spinBox.value()}"
-    if isinstance(w, QTimeEdit):
-        return w.time().toString("HH:mm")
-    if isinstance(w, QDateEdit):
-        return w.date().toString("yyyy-MM-dd")
-    if isinstance(w, QComboBox):
-        return w.currentText()
-    if isinstance(w, QSpinBox):
-        return str(w.value())
-    if isinstance(w, QDoubleSpinBox):
-        return str(w.value())
-    if isinstance(w, QLineEdit):
-        return w.text()
-    return ""
-
-
-def _encodeValueStr(
-    raw_value: str,
-    data_type: str
-) -> str:
-
-    if data_type == "Time":
-        if raw_value.startswith("+"):
-            return raw_value
-        return f"TIME({raw_value})"
-    elif data_type == "Date":
-        if raw_value == "今天":
-            return "CURRENT_DATE"
-        elif raw_value == "明天":
-            return "CURRENT_DATE + 1"
-        return f"DATE({raw_value})"
-    elif data_type == "Boolean":
-        return raw_value
-    elif data_type == "String":
-        escaped = raw_value.replace("'", "''")
-        return f"'{escaped}'"
-    else:
-        return raw_value
-
-
-def _setWidgetValue(
-    w: QWidget,
-    vartype: str,
-    expr: str
-):
-
-    import re
-    s = expr.strip()
-
-    if getattr(w, '_isActionTime', False):
-        timeMatch = re.match(r"TIME\((\d{1,2}:\d{2})\)", s, re.IGNORECASE)
-        if timeMatch:
-            w._modeCombo.setCurrentIndex(0)
-            parts = timeMatch.group(1).split(":")
-            w._timeEdit.setTime(QTime(int(parts[0]), int(parts[1])))
-            return
-        relMatch = re.match(r"^\+(\d+)$", s)
-        if relMatch:
-            w._modeCombo.setCurrentIndex(1)
-            w._spinBox.setValue(int(relMatch.group(1)))
-            return
-        return
-    if getattr(w, '_is_date_action', False) and isinstance(w, QComboBox):
-        if s.upper() in ("CURRENT_DATE", "TODAY"):
-            w.setCurrentIndex(0)
-        elif s.upper() in ("CURRENT_DATE + 1", "TOMORROW"):
-            w.setCurrentIndex(1)
-        else:
-            dateMatch = re.match(
-                r"DATE\((\d{4}-\d{2}-\d{2})\)", s, re.IGNORECASE
-            )
-            if dateMatch:
-                from datetime import datetime, timedelta
-                dateStr = dateMatch.group(1)
-                today = datetime.now().strftime("%Y-%m-%d")
-                tomorrow = (
-                    datetime.now() + timedelta(days=1)
-                ).strftime("%Y-%m-%d")
-                if dateStr == today:
-                    w.setCurrentIndex(0)
-                elif dateStr == tomorrow:
-                    w.setCurrentIndex(1)
-        return
-    if vartype == "Time":
-        m = re.match(r"TIME\((\d{1,2}:\d{2})\)", s, re.IGNORECASE)
-        if m and isinstance(w, QTimeEdit):
-            parts = m.group(1).split(":")
-            w.setTime(QTime(int(parts[0]), int(parts[1])))
-    elif vartype == "Date":
-        m = re.match(r"DATE\((\d{4}-\d{2}-\d{2})\)", s, re.IGNORECASE)
-        if m and isinstance(w, QDateEdit):
-            parts = m.group(1).split("-")
-            w.setDate(QDate(int(parts[0]), int(parts[1]), int(parts[2])))
-    elif vartype == "Boolean" and isinstance(w, QComboBox):
-        for i in range(w.count()):
-            if w.itemData(i) == s.upper():
-                w.setCurrentIndex(i)
-                break
-    elif vartype == "Integer" and isinstance(w, QSpinBox):
-        try:
-            w.setValue(int(s))
-        except ValueError:
-            pass
-    elif vartype == "Float" and isinstance(w, QDoubleSpinBox):
-        try:
-            w.setValue(float(s))
-        except ValueError:
-            pass
-    elif isinstance(w, QLineEdit):
-        inner = s
-        if (inner.startswith("'") and inner.endswith("'")) or \
-           (inner.startswith('"') and inner.endswith('"')):
-            inner = inner[1:-1].replace("''", "'")
-        w.setText(inner)
-
-
-class ActionStepFrame(QFrame):
-
-    def __init__(
-        self,
-        parent=None
-    ):
-        super().__init__(parent)
-
-        self.setupUi()
-        self.connectSignals()
-        self.onTargetChanged(0)
-
-
-    def setupUi(
-        self
-    ):
-
-        self.setFrameShape(QFrame.Shape.StyledPanel)
-        self.setFrameShadow(QFrame.Shadow.Raised)
-        self.setFixedHeight(35)
-
-        layout = QHBoxLayout(self)
-        layout.setContentsMargins(2, 2, 2, 2)
-        layout.setSpacing(4)
-
-        self.targetCombo = _makeSetVarCombo()
-        self.valueWidgetStack = QStackedWidget()
-        self.valueWidgetStack.setFixedHeight(25)
-        self.initValueStack()
-
-        setLabel = QLabel("设置")
-        setLabel.setFixedHeight(25)
-        layout.addWidget(setLabel)
-        layout.addWidget(self.targetCombo)
-        toLabel = QLabel("为")
-        toLabel.setFixedHeight(25)
-        layout.addWidget(toLabel)
-        layout.addWidget(self.valueWidgetStack)
-
-        self.deleteBtn = QPushButton("×")
-        self.deleteBtn.setFixedSize(24, 25)
-        self.deleteBtn.setStyleSheet("color: red; font-weight: bold;")
-        layout.addWidget(self.deleteBtn)
-
-
-    def connectSignals(
-        self
-    ):
-
-        self.targetCombo.currentIndexChanged.connect(self.onTargetChanged)
-
-
-    def initValueStack(
-        self
-    ):
-
-        self._valueWidgets = {}
-        for _, _, vartype in _VAR_COMBO_ITEMS:
-            if vartype not in self._valueWidgets:
-                w = _makeActionValueWidget(vartype)
-                self._valueWidgets[vartype] = w
-                self.valueWidgetStack.addWidget(w)
-        self.valueWidgetStack.setCurrentWidget(
-            self._valueWidgets.get("String", self.valueWidgetStack.widget(0))
-        )
-
-
-    def getTarget(
-        self
-    ) -> str:
-
-        data = self.targetCombo.currentData()
-        return data[0] if data else ""
-
-
-    def getTargetType(
-        self
-    ) -> str:
-
-        data = self.targetCombo.currentData()
-        return data[1] if data else "String"
-
-
-    def getValueRaw(
-        self
-    ) -> str:
-
-        currentType = self.getTargetType()
-        w = self._valueWidgets.get(currentType)
-        if w:
-            return _getValueFromWidget(w)
-        return ""
-
-
-    def toScriptLine(
-        self
-    ) -> str:
-
-        target = self.getTarget()
-        if not target:
-            return ""
-        rawVal = self.getValueRaw()
-        targetType = self.getTargetType()
-        encoded = _encodeValueStr(rawVal, targetType)
-        if targetType == "Time" and rawVal.startswith("+"):
-            hours = rawVal[1:]
-            return f"    {target} .ADD. {hours}"
-        return f"    SET {target} = {encoded}"
-
-
-    def loadFromScript(
-        self,
-        targetVar: str,
-        valueExpr: str
-    ):
-
-        for idx in range(self.targetCombo.count()):
-            data = self.targetCombo.itemData(idx)
-            if data and data[0] == targetVar:
-                self.targetCombo.setCurrentIndex(idx)
-                break
-        self.setValueFromExpr(valueExpr)
-
-
-    def setValueFromExpr(
-        self,
-        expr: str
-    ):
-
-        targetType = self.getTargetType()
-        w = self._valueWidgets.get(targetType)
-        if not w:
-            return
-        _setWidgetValue(w, targetType, expr)
-
-    @Slot(int)
-    def onTargetChanged(
-        self,
-        idx
-    ):
-        if idx < 0:
-            return
-        data = self.targetCombo.itemData(idx)
-        if data:
-            _, vartype = data
-            w = self._valueWidgets.get(vartype)
-            if w:
-                self.valueWidgetStack.setCurrentWidget(w)
-
-
-class ConditionalBlock(QGroupBox):
-
-    def __init__(
-        self,
-        blockIndex: int,
-        parent=None
-    ):
-        super().__init__(parent)
-
-        self.blockIndex = blockIndex
-        self._actionWidgets = []
-
-        self.setupUi()
-        self.connectSignals()
-        self.onOperandChanged(0)
-
-
-    def setupUi(
-        self
-    ):
-
-        self.setStyleSheet(
-            "QGroupBox { font-weight: bold; border: 1px solid #ccc; "
-            "margin-top: 5px; padding-top: 5px; }"
-        )
-        self.setSizePolicy(
-            QSizePolicy.Policy.Preferred,
-            QSizePolicy.Policy.Fixed
-        )
-
-        mainLayout = QVBoxLayout(self)
-        mainLayout.setSpacing(4)
-        mainLayout.setContentsMargins(5, 5, 5, 5)
-
-        headerLayout = QHBoxLayout()
-        self.typeCombo = QComboBox()
-        self.typeCombo.addItem("IF", "IF")
-        self.typeCombo.addItem("ELSE IF", "ELSE IF")
-        self.typeCombo.addItem("ELSE", "ELSE")
-        if self.blockIndex == 0:
-            self.typeCombo.setEnabled(False)
-        typeLabel = QLabel("类型:")
-        typeLabel.setFixedHeight(25)
-        headerLayout.addWidget(typeLabel)
-        headerLayout.addWidget(self.typeCombo)
-        headerLayout.addStretch()
-        self.deleteBlockBtn = QPushButton("删除此块")
-        self.deleteBlockBtn.setStyleSheet("color: red;")
-        self.deleteBlockBtn.setFixedHeight(25)
-        headerLayout.addWidget(self.deleteBlockBtn)
-        mainLayout.addLayout(headerLayout)
-
-        self.conditionWidget = QWidget()
-        self.conditionWidget.setFixedHeight(60)
-        condLayout = QHBoxLayout(self.conditionWidget)
-        condLayout.setContentsMargins(0, 0, 0, 0)
-        ifLabel = QLabel("如果")
-        ifLabel.setFixedHeight(25)
-        condLayout.addWidget(ifLabel)
-        self.operandCombo = _makeVarCombo()
-        condLayout.addWidget(self.operandCombo)
-        self.opCombo = _makeOpCombo()
-        condLayout.addWidget(self.opCombo)
-
-        self.condValueStack = QStackedWidget()
-        self.condValueStack.setFixedHeight(25)
-        self._condValueWidgets = {}
-        for vartype in ["Time", "Date", "String", "Integer", "Float", "Boolean"]:
-            w = _makeValueWidget(vartype)
-            self._condValueWidgets[vartype] = w
-            self.condValueStack.addWidget(w)
-        self.condValueStack.setCurrentWidget(self._condValueWidgets.get("String"))
-        condLayout.addWidget(self.condValueStack)
-        mainLayout.addWidget(self.conditionWidget)
-
-        self.actionLabel = QLabel("执行步骤:")
-        self.actionLabel.setFixedHeight(25)
-        mainLayout.addWidget(self.actionLabel)
-
-        self.actionsLayout = QVBoxLayout()
-        self.actionsLayout.setSpacing(2)
-        mainLayout.addLayout(self.actionsLayout)
-
-        self.addActionBtn = QPushButton("+ 添加执行步骤")
-        self.addActionBtn.setFixedHeight(25)
-        mainLayout.addWidget(self.addActionBtn)
-
-
-    def connectSignals(
-        self
-    ):
-
-        self.operandCombo.currentIndexChanged.connect(self.onOperandChanged)
-        self.typeCombo.currentIndexChanged.connect(self.onTypeChanged)
-        self.addActionBtn.clicked.connect(self.addActionStep)
-
-
-    def removeActionStep(
-        self,
-        step: ActionStepFrame
-    ):
-
-        if step in self._actionWidgets:
-            self._actionWidgets.remove(step)
-            self.actionsLayout.removeWidget(step)
-            step.hide()
-            step.deleteLater()
-
-
-    def getBlockType(
-        self
-    ) -> str:
-
-        return self.typeCombo.currentData()
-
-
-    def toScriptLines(
-        self
-    ) -> list:
-
-        blockType = self.getBlockType()
-        lines = []
-
-        if blockType in ("IF", "ELSE IF"):
-            operand = self.operandCombo.currentData()
-            operandName = operand[0] if operand else ""
-            operandType = operand[1] if operand else "String"
-            opSym = self.opCombo.currentData()
-            rawVal = _getValueFromWidget(
-                self._condValueWidgets.get(operandType, QLineEdit())
-            )
-            encodedVal = _encodeValueStr(rawVal, operandType)
-            if blockType == "IF":
-                lines.append(f"IF({operandName} {opSym} {encodedVal}) THEN")
-            else:
-                lines.append(f"ELSE IF({operandName} {opSym} {encodedVal}) THEN")
-        else:
-            lines.append("ELSE")
-        for step in self._actionWidgets:
-            scriptLine = step.toScriptLine()
-            if scriptLine:
-                lines.append(scriptLine)
-
-        return lines
-
-
-    def getConditionSummary(
-        self
-    ) -> str:
-
-        bt = self.getBlockType()
-        if bt == "ELSE":
-            return "ELSE"
-        operandData = self.operandCombo.currentData()
-        if not operandData:
-            return bt
-        operandDisplay = self.operandCombo.currentText()
-        opDisplay = self.opCombo.currentText()
-        rawVal = self.getConditionRawValuePreview()
-        return f"{bt} ({operandDisplay} {opDisplay} {rawVal})"
-
-
-    def getConditionRawValuePreview(
-        self
-    ) -> str:
-
-        data = self.operandCombo.currentData()
-        if not data:
-            return ""
-        _, vartype = data
-        w = self._condValueWidgets.get(vartype)
-        if w:
-            return _getValueFromWidget(w)
-        return ""
-
-
-    def countActionSteps(
-        self
-    ) -> int:
-
-        return len(self._actionWidgets)
-
-    @Slot(int)
-    def onOperandChanged(
-        self,
-        idx
-    ):
-        if idx < 0:
-            return
-        data = self.operandCombo.itemData(idx)
-        if data:
-            _, vartype = data
-            w = self._condValueWidgets.get(vartype)
-            if w:
-                self.condValueStack.setCurrentWidget(w)
-
-    @Slot(int)
-    def onTypeChanged(
-        self,
-        idx
-    ):
-        isCond = self.typeCombo.currentData() in ("IF", "ELSE IF")
-        self.conditionWidget.setVisible(isCond)
-        self.actionLabel.setText("执行步骤:" if isCond else "ELSE 执行步骤:")
-
-    @Slot()
-    def addActionStep(
-        self
-    ):
-
-        step = ActionStepFrame(self)
-        step.deleteBtn.clicked.connect(lambda: self.removeActionStep(step))
-        self._actionWidgets.append(step)
-        self.actionsLayout.addWidget(step)
-
-
-class ALAutoScriptOrchDialog(QDialog):
-
-    def __init__(
-        self,
-        parent=None,
-        existingScript: str = ""
-    ):
-        super().__init__(parent)
-        self._blocks: list[ConditionalBlock] = []
-
-        self.modifyUi()
-        self.connectSignals()
-
-        if existingScript and existingScript.strip():
-            self.loadFromScript(existingScript)
-        else:
-            self.addBlock()
-        self._scrollLayout.addStretch()
-
-
-    def modifyUi(
-        self
-    ):
-
-        self.setWindowTitle("AutoScript 指令编排 - AutoLibrary")
-        self.setMinimumSize(420, 400)
-        self.setModal(True)
-        mainLayout = QVBoxLayout(self)
-        scroll = QScrollArea()
-        scroll.setWidgetResizable(True)
-        scroll.setFrameShape(QFrame.Shape.NoFrame)
-        scrollContent = QWidget()
-        self._scrollLayout = QVBoxLayout(scrollContent)
-        self._scrollLayout.setSpacing(5)
-        scroll.setWidget(scrollContent)
-        mainLayout.addWidget(scroll)
-        addBlockLayout = QHBoxLayout()
-        self.addBlockBtn = QPushButton("+ 添加判断块")
-        self.addBlockBtn.setFixedHeight(25)
-        addBlockLayout.addStretch()
-        addBlockLayout.addWidget(self.addBlockBtn)
-        addBlockLayout.addStretch()
-        mainLayout.addLayout(addBlockLayout)
-        self.btnBox = QDialogButtonBox(
-            QDialogButtonBox.StandardButton.Ok |
-            QDialogButtonBox.StandardButton.Cancel
-        )
-        self.btnBox.button(QDialogButtonBox.StandardButton.Ok).setText("确定")
-        self.btnBox.button(QDialogButtonBox.StandardButton.Cancel).setText("取消")
-        mainLayout.addWidget(self.btnBox)
-
-
-    def connectSignals(
-        self
-    ):
-
-        self.btnBox.accepted.connect(self.accept)
-        self.btnBox.rejected.connect(self.reject)
-        self.addBlockBtn.clicked.connect(self.addBlock)
-
-
-    def removeBlock(
-        self,
-        block: ConditionalBlock
-    ):
-
-        if block in self._blocks:
-            self._blocks.remove(block)
-            self._scrollLayout.removeWidget(block)
-            block.hide()
-            block.deleteLater()
-
-
-    def getScript(
-        self
-    ) -> str:
-
-        parts = []
-        for i, block in enumerate(self._blocks):
-            blockType = block.getBlockType()
-            if blockType == "IF" and i > 0:
-                parts.append("ENDIF")
-            lines = block.toScriptLines()
-            parts.extend(lines)
-        if self._blocks and self._blocks[0].getBlockType() == "IF":
-            parts.append("ENDIF")
-        return "\n".join(parts)
-
-
-    def getScriptPreview(
-        self
-    ) -> str:
-
-        s = self.getScript()
-        if len(s) > 10:
-            return s[:7] + "..."
-        return s
-
-
-    def loadFromScript(
-        self,
-        script: str
-    ):
-
-        import re
-        lines = [l.strip() for l in script.split("\n") if l.strip()]
-        if not lines:
-            self.addBlock()
-            return
-
-        currentBlock = None
-        currentBlockType = None
-        actionsBuffer = []
-
-        def flushBlock():
-            nonlocal currentBlock, currentBlockType, actionsBuffer
-            if currentBlock is None:
-                return
-            typeIdxMap = {"IF": 0, "ELSE IF": 1, "ELSE": 2}
-            idx = typeIdxMap.get(currentBlockType, 0)
-            currentBlock.typeCombo.setCurrentIndex(idx)
-            currentBlock.onTypeChanged(idx)
-            for oldStep in list(currentBlock._actionWidgets):
-                currentBlock.removeActionStep(oldStep)
-            for target, valueExpr in actionsBuffer:
-                currentBlock.addActionStep()
-                step = currentBlock._actionWidgets[-1]
-                step.loadFromScript(target, valueExpr)
-        self._blocks.clear()
-        while self._scrollLayout.count():
-            item = self._scrollLayout.takeAt(0)
-            if item.widget():
-                item.widget().deleteLater()
-        for line in lines:
-            upper = line.upper()
-            ifMatch = re.match(r"^IF\((.+)\)\s*THEN\s*$", upper)
-            if ifMatch:
-                flushBlock()
-                currentBlockType = "IF"
-                actionsBuffer = []
-                self.addBlock()
-                currentBlock = self._blocks[-1]
-                self.parseConditionToBlock(currentBlock, ifMatch.group(1))
-                continue
-            elifIfMatch = re.match(r"^ELSE\s+IF\((.+)\)\s*THEN\s*$", upper)
-            if elifIfMatch:
-                flushBlock()
-                currentBlockType = "ELSE IF"
-                actionsBuffer = []
-                self.addBlock()
-                currentBlock = self._blocks[-1]
-                self.parseConditionToBlock(currentBlock, elifIfMatch.group(1))
-                continue
-            if upper == "ELSE":
-                flushBlock()
-                currentBlockType = "ELSE"
-                actionsBuffer = []
-                self.addBlock()
-                currentBlock = self._blocks[-1]
-                currentBlock.conditionWidget.setVisible(False)
-                continue
-            setMatch = re.match(r"^SET\s+(\w+)\s*=\s*(.+)$", line, re.IGNORECASE)
-            if setMatch:
-                target = setMatch.group(1).strip()
-                valueExpr = setMatch.group(2).strip()
-                actionsBuffer.append((target, valueExpr))
-                continue
-            addMatch = re.match(r"^(\w+)\s+\.ADD\.\s+(\d+)$", line, re.IGNORECASE)
-            if addMatch:
-                target = addMatch.group(1).strip()
-                hours = addMatch.group(2).strip()
-                actionsBuffer.append((target, f"+{hours}"))
-                continue
-            if upper in ("ENDIF", "END IF"):
-                flushBlock()
-                currentBlock = None
-                currentBlockType = None
-                actionsBuffer = []
-                continue
-        flushBlock()
-        if not self._blocks:
-            self.addBlock()
-
-
-    def parseConditionToBlock(
-        self,
-        block: ConditionalBlock,
-        condStr: str
-    ):
-
-        condStr = condStr.strip()
-        for _, opSym in OP_ITEMS:
-            idx = condStr.upper().find(opSym)
-            if idx >= 0:
-                leftPart = condStr[:idx].strip()
-                rightPart = condStr[idx + len(opSym):].strip()
-                for ci in range(block.operandCombo.count()):
-                    data = block.operandCombo.itemData(ci)
-                    if data and data[0] == leftPart:
-                        block.operandCombo.setCurrentIndex(ci)
-                        break
-                for oi in range(block.opCombo.count()):
-                    if block.opCombo.itemData(oi) == opSym:
-                        block.opCombo.setCurrentIndex(oi)
-                        break
-                opData = block.operandCombo.currentData()
-                vartype = opData[1] if opData else "String"
-                w = block._condValueWidgets.get(vartype)
-                if w:
-                    _setWidgetValue(w, vartype, rightPart)
-                return
-
-    @Slot()
-    def addBlock(
-        self
-    ):
-
-        block = ConditionalBlock(len(self._blocks), self)
-        block.deleteBlockBtn.clicked.connect(lambda: self.removeBlock(block))
-        self._blocks.append(block)
-        block.addActionStep()
-        if self._scrollLayout.count() > 0:
-            lastItem = self._scrollLayout.itemAt(
-                self._scrollLayout.count() - 1
-            )
-            if lastItem and lastItem.spacerItem():
-                self._scrollLayout.insertWidget(
-                    self._scrollLayout.count() - 1, block
-                )
-                return
-        self._scrollLayout.addWidget(block)

src/gui/ALAutoScriptOrchDialog/__init__.py

@@ -0,0 +1,3 @@
+from gui.ALAutoScriptOrchDialog._dialog import ALAutoScriptOrchDialog
+
+__all__ = ["ALAutoScriptOrchDialog"]

src/gui/ALAutoScriptOrchDialog/_blocks.py

@@ -0,0 +1,280 @@
+# -*- coding: utf-8 -*-
+"""
+Copyright (c) 2026 KenanZhu.
+All rights reserved.
+
+This software is provided "as is", without any warranty of any kind.
+You may use, modify, and distribute this file under the terms of the MIT License.
+See the LICENSE file for details.
+"""
+"""
+    Conditional block widget for the AutoScript orchestration dialog.
+"""
+from PySide6.QtCore import Slot
+from PySide6.QtWidgets import (
+    QComboBox,
+    QGroupBox,
+    QHBoxLayout,
+    QLabel,
+    QPushButton,
+    QSizePolicy,
+    QVBoxLayout,
+    QWidget,
+)
+
+from gui.ALAutoScriptOrchDialog._widgets import (
+    ActionStepFrame,
+    ConditionRowFrame,
+)
+
+
+class ConditionalBlock(QGroupBox):
+
+    def __init__(
+        self,
+        blockIndex: int,
+        varMgr = None,
+        parent = None
+    ):
+
+        super().__init__(parent)
+        self.blockIndex = blockIndex
+        self._varMgr = varMgr
+        self._actionWidgets = []
+        self._conditionRows = []
+
+        self.setupUi()
+        self.connectSignals()
+        self.addInitialConditionRow()
+
+
+    def setupUi(
+        self
+    ):
+
+        self.setUpdatesEnabled(False)
+        self.setStyleSheet(
+            "QGroupBox { font-weight: bold; border: 1px solid #ccc; "
+            "margin-top: 5px; padding-top: 5px; }"
+        )
+        self.setSizePolicy(QSizePolicy.Preferred, QSizePolicy.Fixed)
+        mainLayout = QVBoxLayout(self)
+        mainLayout.setSpacing(6)
+        mainLayout.setContentsMargins(8, 8, 8, 8)
+        headerLayout = QHBoxLayout()
+        headerLayout.setSpacing(8)
+        self.typeCombo = QComboBox(self)
+        self.typeCombo.addItem("IF", "IF")
+        self.typeCombo.addItem("ELSE IF", "ELSE IF")
+        self.typeCombo.addItem("ELSE", "ELSE")
+        self.typeCombo.setFixedHeight(25)
+        if self.blockIndex == 0:
+            self.typeCombo.setEnabled(False)
+        headerLayout.addWidget(QLabel("类型:", self))
+        headerLayout.addWidget(self.typeCombo)
+        headerLayout.addStretch()
+        self.deleteBlockBtn = QPushButton("删除此块", self)
+        self.deleteBlockBtn.setStyleSheet("color: red;")
+        self.deleteBlockBtn.setFixedHeight(25)
+        headerLayout.addWidget(self.deleteBlockBtn)
+        mainLayout.addLayout(headerLayout)
+        self.conditionWidget = QWidget(self)
+        self.conditionWidget.setSizePolicy(
+            QSizePolicy.Preferred, QSizePolicy.Preferred
+        )
+        condLayout = QVBoxLayout(self.conditionWidget)
+        condLayout.setContentsMargins(4, 4, 4, 4)
+        condLayout.setSpacing(6)
+        self.condRowsLayout = QVBoxLayout()
+        self.condRowsLayout.setSpacing(4)
+        condLayout.addLayout(self.condRowsLayout)
+        self.addCondBtn = QPushButton("+ 添加条件", self.conditionWidget)
+        self.addCondBtn.setFixedHeight(25)
+        condLayout.addWidget(self.addCondBtn)
+        mainLayout.addWidget(self.conditionWidget)
+        self.actionLabel = QLabel("执行步骤:", self)
+        self.actionLabel.setFixedHeight(25)
+        mainLayout.addWidget(self.actionLabel)
+        self.actionsLayout = QVBoxLayout()
+        self.actionsLayout.setSpacing(4)
+        mainLayout.addLayout(self.actionsLayout)
+        self.addActionBtn = QPushButton("+ 添加执行步骤", self)
+        self.addActionBtn.setFixedHeight(25)
+        mainLayout.addWidget(self.addActionBtn)
+        self.setUpdatesEnabled(True)
+
+
+    def connectSignals(
+        self
+    ):
+
+        self.typeCombo.currentIndexChanged.connect(self.onTypeChanged)
+        self.addCondBtn.clicked.connect(self.addConditionRow)
+        self.addActionBtn.clicked.connect(self.addActionStep)
+
+
+    def addInitialConditionRow(
+        self
+    ):
+
+        row = ConditionRowFrame(
+            self._varMgr, self.blockIndex,
+            isFirst=True, parent=self
+        )
+        self._conditionRows.append(row)
+        self.condRowsLayout.addWidget(row)
+
+
+    def addConditionRow(
+        self
+    ):
+
+        row = ConditionRowFrame(
+            self._varMgr, self.blockIndex,
+            isFirst=False, parent=self
+        )
+        row.deleteBtn.clicked.connect(lambda: self.removeConditionRow(row))
+        self._conditionRows.append(row)
+        self.condRowsLayout.addWidget(row)
+
+
+    def removeConditionRow(
+        self,
+        row: ConditionRowFrame
+    ):
+
+        if row in self._conditionRows and len(self._conditionRows) > 1:
+            self._conditionRows.remove(row)
+            self.condRowsLayout.removeWidget(row)
+            row.hide()
+            row.deleteLater()
+
+
+    def addActionStep(
+        self
+    ):
+
+        step = ActionStepFrame(self._varMgr, self.blockIndex, parent=self)
+        step.deleteBtn.clicked.connect(lambda: self.removeActionStep(step))
+        self._actionWidgets.append(step)
+        self.actionsLayout.addWidget(step)
+
+
+    def removeActionStep(
+        self,
+        step: ActionStepFrame
+    ):
+
+        if step in self._actionWidgets:
+            self._actionWidgets.remove(step)
+            self.actionsLayout.removeWidget(step)
+            step.hide()
+            step.deleteLater()
+
+    @Slot(int)
+    def onTypeChanged(
+        self,
+        _idx
+    ):
+
+        isCond = self.typeCombo.currentData() in ("IF", "ELSE IF")
+        self.conditionWidget.setVisible(isCond)
+        self.actionLabel.setText(
+            "执行步骤:" if isCond else "ELSE 执行步骤:"
+        )
+
+
+    def getBlockType(
+        self
+    ) -> str:
+
+        return self.typeCombo.currentData()
+
+
+    def getConditionRows(
+        self
+    ):
+
+        return list(self._conditionRows)
+
+
+    def getActionSteps(
+        self
+    ):
+
+        return list(self._actionWidgets)
+
+
+    def countActionSteps(
+        self
+    ) -> int:
+
+        return len(self._actionWidgets)
+
+
+    def toScriptLines(
+        self
+    ) -> list:
+        """
+            Generate Lua script lines for this conditional block.
+        """
+
+        blockType = self.getBlockType()
+        lines = []
+        if blockType in ("IF", "ELSE IF"):
+            condTexts = [
+                r.toConditionText() for r in self._conditionRows if r.toConditionText()
+            ]
+            if not condTexts:
+                condTexts = ["true"]
+
+            if len(condTexts) == 1:
+                combined = condTexts[0]
+            else:
+                parts = []
+                for i, ct in enumerate(condTexts):
+                    if i > 0:
+                        logic = self._conditionRows[i].getLogic() or "and"
+                        parts.append(f" {logic} ")
+                    parts.append(f"({ct})")
+                combined = "".join(parts)
+            if blockType == "IF":
+                lines.append(f"if {combined} then")
+            else:
+                lines.append(f"elseif {combined} then")
+        else:
+            lines.append("else")
+        for step in self._actionWidgets:
+            scriptLine = step.toScriptLine()
+            if scriptLine:
+                lines.append(scriptLine)
+        return lines
+
+
+    def refreshVarCombos(
+        self
+    ):
+
+        for row in self._conditionRows:
+            row.refreshVarCombos()
+        for step in self._actionWidgets:
+            step.refreshVarCombos()
+
+
+    def setPrevBlockType(
+        self,
+        prevType: str | None
+    ):
+
+        model = self.typeCombo.model()
+        if model is None:
+            return
+        for data in ("ELSE IF", "ELSE"):
+            idx = self.typeCombo.findData(data)
+            if idx < 0:
+                continue
+            item = model.item(idx)
+            shouldEnable = prevType != "ELSE"
+            item.setEnabled(shouldEnable)
+        if prevType == "ELSE" and self.typeCombo.currentData() in ("ELSE IF", "ELSE"):
+            self.typeCombo.setCurrentIndex(0)

src/gui/ALAutoScriptOrchDialog/_dialog.py

@@ -0,0 +1,170 @@
+# -*- coding: utf-8 -*-
+"""
+Copyright (c) 2026 KenanZhu.
+All rights reserved.
+
+This software is provided "as is", without any warranty of any kind.
+You may use, modify, and distribute this file under the terms of the MIT License.
+See the LICENSE file for details.
+"""
+"""
+    Orchestration dialog for visually composing AutoScript scripts.
+"""
+from PySide6.QtCore import Slot
+from PySide6.QtWidgets import (
+    QDialog,
+    QDialogButtonBox,
+    QFrame,
+    QMessageBox,
+    QPushButton,
+    QScrollArea,
+    QVBoxLayout,
+    QWidget,
+)
+
+from gui.ALAutoScriptOrchDialog._helpers import VariableManager
+from gui.ALAutoScriptOrchDialog._blocks import ConditionalBlock
+
+
+class ALAutoScriptOrchDialog(QDialog):
+
+    def __init__(
+        self,
+        parent = None
+    ):
+
+        super().__init__(parent)
+        self._blocks = []
+        self._varMgr = VariableManager(self)
+
+        self.setupUi()
+        self.connectSignals()
+        self.addBlock()
+        self.scrollLayout.addStretch()
+
+
+    def setupUi(
+        self
+    ):
+
+        self.setWindowTitle("AutoScript 指令编排 - AutoLibrary")
+        self.setMinimumSize(640, 600)
+        self.setModal(True)
+        mainLayout = QVBoxLayout(self)
+        scroll = QScrollArea()
+        scroll.setWidgetResizable(True)
+        scroll.setFrameShape(QFrame.NoFrame)
+        scrollContent = QWidget()
+        self.scrollLayout = QVBoxLayout(scrollContent)
+        self.scrollLayout.setSpacing(5)
+        scroll.setWidget(scrollContent)
+        mainLayout.addWidget(scroll)
+        self.addBlockBtn = QPushButton("+ 添加判断块")
+        self.addBlockBtn.setFixedHeight(25)
+        mainLayout.addWidget(self.addBlockBtn)
+        self.btnBox = QDialogButtonBox(
+            QDialogButtonBox.StandardButton.Ok |
+            QDialogButtonBox.StandardButton.Cancel
+        )
+        self.btnBox.button(QDialogButtonBox.StandardButton.Ok).setText("确定")
+        self.btnBox.button(QDialogButtonBox.StandardButton.Cancel).setText("取消")
+        mainLayout.addWidget(self.btnBox)
+
+
+    def connectSignals(
+        self
+    ):
+
+        self.btnBox.accepted.connect(self.onAccept)
+        self.btnBox.rejected.connect(self.reject)
+        self.addBlockBtn.clicked.connect(self.addBlock)
+
+
+    def _updateBlockTypeRestrictions(
+        self
+    ):
+
+        prevType = None
+        for block in self._blocks:
+            block.setPrevBlockType(prevType)
+            prevType = block.getBlockType()
+
+
+    def addBlock(
+        self
+    ):
+
+        block = ConditionalBlock(
+            len(self._blocks), self._varMgr, parent=self
+        )
+        block.deleteBlockBtn.clicked.connect(lambda: self.removeBlock(block))
+        block.typeCombo.currentIndexChanged.connect(self._updateBlockTypeRestrictions)
+        block.addActionStep()
+        self._blocks.append(block)
+        self._updateBlockTypeRestrictions()
+        if self.scrollLayout.count() > 0:
+            lastItem = self.scrollLayout.itemAt(
+                self.scrollLayout.count() - 1
+            )
+            if lastItem and lastItem.spacerItem():
+                self.scrollLayout.insertWidget(
+                    self.scrollLayout.count() - 1, block
+                )
+                return
+        self.scrollLayout.addWidget(block)
+
+
+    def removeBlock(
+        self,
+        block: ConditionalBlock
+    ):
+
+        if len(self._blocks) <= 1:
+            QMessageBox.information(self, "提示", "至少保留一个判断块。")
+            return
+        if block in self._blocks:
+            self._blocks.remove(block)
+            self.scrollLayout.removeWidget(block)
+            block.hide()
+            block.deleteLater()
+        for i, blk in enumerate(self._blocks):
+            blk.blockIndex = i
+            if i == 0:
+                blk.typeCombo.setEnabled(False)
+                blk.typeCombo.setCurrentIndex(0)
+            else:
+                blk.typeCombo.setEnabled(True)
+            blk.refreshVarCombos()
+        self._updateBlockTypeRestrictions()
+
+
+    def getScript(
+        self
+    ) -> str:
+        """
+            Generate the complete Lua script from all blocks.
+        """
+
+        parts = []
+        prevType = None
+        for block in self._blocks:
+            blockType = block.getBlockType()
+            if blockType == "IF" and prevType is not None:
+                parts.append("end")
+            lines = block.toScriptLines()
+            parts.extend(lines)
+            prevType = blockType
+        if self._blocks and self._blocks[0].getBlockType() == "IF":
+            parts.append("end")
+        return "\n".join(parts)
+
+    @Slot()
+    def onAccept(
+        self
+    ):
+
+        script = self.getScript().strip()
+        if not script:
+            QMessageBox.warning(self, "提示", "脚本内容为空，请添加至少一个操作步骤。")
+            return
+        self.accept()

src/gui/ALAutoScriptOrchDialog/_helpers.py

@@ -0,0 +1,797 @@
+# -*- coding: utf-8 -*-
+"""
+Copyright (c) 2026 KenanZhu.
+All rights reserved.
+
+This software is provided "as is", without any warranty of any kind.
+You may use, modify, and distribute this file under the terms of the MIT License.
+See the LICENSE file for details.
+"""
+"""
+    Helper utilities and constants for the AutoScript orchestration dialog.
+"""
+import re
+
+from PySide6.QtCore import (
+    QObject,
+    QDate,
+    QTime
+)
+from PySide6.QtWidgets import (
+    QComboBox,
+    QDateEdit,
+    QDoubleSpinBox,
+    QHBoxLayout,
+    QLabel,
+    QLineEdit,
+    QSizePolicy,
+    QSpinBox,
+    QStackedWidget,
+    QTimeEdit,
+    QWidget,
+)
+
+from autoscript import (
+    ALL_VARIABLES,
+)
+
+# Types that support arithmetic operations (add/sub)
+ARITH_TYPES = {"Date", "Time", "Int", "Float"}
+VAR_TYPE_ORDER = [
+    "String",
+    "Int",
+    "Float",
+    "Boolean",
+    "Date",
+    "Time"
+]
+PRESET_VARIABLES = [
+    {
+        "name": name.upper(),
+        "type": vtype,
+        "display": display
+    }
+    for display, (name, vtype) in ALL_VARIABLES.items()
+]
+PRESET_NAMES = {
+    p["name"] for p in PRESET_VARIABLES
+}
+# Operator display names (UI-specific), using Lua operator symbols
+_COMPARE_DISPLAY_MAP = {
+    "==": "等于",
+    "~=": "不等于",
+    ">": "大于",
+    "<": "小于",
+    ">=": "大于等于",
+    "<=": "小于等于",
+}
+COMPARE_OPERATORS = sorted(
+    [(name, op) for op, name in _COMPARE_DISPLAY_MAP.items()],
+    key=lambda x: len(x[1]), reverse=True
+)
+LOGIC_OPERATORS = [
+    ("并且 (and)", "and"),
+    ("或者 (or)", "or"),
+]
+ACTION_TYPES = [
+    ("设置为", "set"),
+    ("增加", "add"),
+    ("减少", "sub"),
+]
+DATE_RELATIVE_OPTIONS = [
+    ("前天", "day_before_yesterday"),
+    ("昨天", "yesterday"),
+    ("今天", "today"),
+    ("明天", "tomorrow"),
+    ("后天", "day_after_tomorrow")
+]
+DATE_OFFSET_UNITS = [
+    ("天", "days"),
+    ("周", "weeks"),
+    ("月", "months"),
+    ("年", "years"),
+]
+
+
+class VariableManager(QObject):
+
+    def __init__(
+        self,
+        parent = None
+    ):
+
+        super().__init__(parent)
+        self._vars = []
+        self._nameMap = {}
+
+        self._initPresetVars()
+
+
+    def _initPresetVars(
+        self
+    ):
+
+        for p in PRESET_VARIABLES:
+            entry = {"name": p["name"], "type": p["type"], "display": p["display"]}
+            self._vars.append(entry)
+            self._nameMap[p["name"]] = entry
+
+
+    def getInfoByName(
+        self,
+        name: str
+    ):
+
+        return self._nameMap.get(name.upper().strip())
+
+
+    def populateCombo(
+        self,
+        combo: QComboBox
+    ):
+
+        currentData = combo.currentData()
+        combo.blockSignals(True)
+        combo.clear()
+        for entry in self._vars:
+            combo.addItem(
+                entry["display"],
+                (entry["name"], entry["type"])
+            )
+        if currentData:
+            for i in range(combo.count()):
+                d = combo.itemData(i)
+                if d and d[0] == currentData[0]:
+                    combo.setCurrentIndex(i)
+                    break
+        combo.blockSignals(False)
+
+
+    def findExactNameEntry(
+        self,
+        combo: QComboBox,
+        name: str
+    ) -> int:
+
+        name = name.upper().strip()
+        for i in range(combo.count()):
+            d = combo.itemData(i)
+            if d and len(d) >= 1 and d[0].upper().strip() == name:
+                return i
+        return -1
+
+
+def makeValueWidget(
+    var_type: str,
+    parent: QWidget = None
+) -> QWidget:
+
+    if var_type == "Int":
+        w = QSpinBox(parent)
+        w.setRange(-999999, 999999)
+        w.setFixedHeight(25)
+        w.setMinimumWidth(100)
+        return w
+    if var_type == "Float":
+        w = QDoubleSpinBox(parent)
+        w.setRange(-999999.0, 999999.0)
+        w.setDecimals(2)
+        w.setFixedHeight(25)
+        w.setMinimumWidth(100)
+        return w
+    if var_type == "String":
+        w = QLineEdit(parent)
+        w.setPlaceholderText("输入值")
+        w.setFixedHeight(25)
+        w.setMinimumWidth(120)
+        return w
+    if var_type == "Boolean":
+        w = QComboBox(parent)
+        w.addItem("是 (true)", "true")
+        w.addItem("否 (false)", "false")
+        w.setFixedHeight(25)
+        w.setMinimumWidth(100)
+        return w
+    if var_type == "Date":
+        return _DateInputContainer(parent)
+    if var_type == "Time":
+        return _TimeInputContainer(parent)
+    w = QLineEdit(parent)
+    w.setPlaceholderText("输入值")
+    w.setFixedHeight(25)
+    w.setMinimumWidth(120)
+    return w
+
+
+def makeOffsetWidget(
+    var_type: str,
+    parent: QWidget = None
+) -> QWidget:
+
+    if var_type == "Int":
+        w = QSpinBox(parent)
+        w.setRange(-999999, 999999)
+        w.setFixedHeight(25)
+        w.setMinimumWidth(100)
+        return w
+    if var_type == "Float":
+        w = QDoubleSpinBox(parent)
+        w.setRange(-999999.0, 999999.0)
+        w.setDecimals(2)
+        w.setFixedHeight(25)
+        w.setMinimumWidth(100)
+        return w
+    if var_type == "Date":
+        return _DateOffsetContainer(parent)
+    if var_type == "Time":
+        return _TimeOffsetContainer(parent)
+    w = QLabel("(不支持该操作)", parent)
+    w.setFixedHeight(25)
+    return w
+
+
+def makeVarRefCombo(
+    parent: QWidget = None
+) -> QComboBox:
+
+    cb = QComboBox(parent)
+    cb.setFixedHeight(25)
+    cb.setMinimumWidth(120)
+    cb.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed)
+    return cb
+
+
+def makeComboWidget(
+    items,
+    min_width: int = 80,
+    parent: QWidget = None
+) -> QComboBox:
+
+    cb = QComboBox(parent)
+    for display, data in items:
+        cb.addItem(display, data)
+    cb.setFixedHeight(25)
+    cb.setMinimumWidth(min_width)
+    return cb
+
+
+def makeLabel(
+    text: str,
+    parent: QWidget = None,
+    width: int = None
+) -> QLabel:
+
+    lbl = QLabel(text, parent)
+    lbl.setFixedHeight(25)
+    if width:
+        lbl.setFixedWidth(width)
+    return lbl
+
+
+class _DateInputContainer(QWidget):
+
+    def __init__(
+        self,
+        parent = None
+    ):
+
+        super().__init__(parent)
+        self._dynamicItems = {}  # index -> raw expression, for one-way parsed items
+        self.setupUi()
+
+
+    def setupUi(
+        self
+    ):
+
+        layout = QHBoxLayout(self)
+        layout.setContentsMargins(0, 0, 0, 0)
+        layout.setSpacing(4)
+        self._modeCombo = QComboBox(self)
+        self._modeCombo.addItem("相对日期", "relative")
+        self._modeCombo.addItem("绝对日期", "absolute")
+        self._modeCombo.setFixedHeight(25)
+        self._stack = QStackedWidget(self)
+        self._relCombo = QComboBox(self)
+        for display, data in DATE_RELATIVE_OPTIONS:
+            self._relCombo.addItem(display, data)
+        self._relCombo.setFixedHeight(25)
+        self._stack.addWidget(self._relCombo)
+        self._dateEdit = QDateEdit(self)
+        self._dateEdit.setDisplayFormat("yyyy-MM-dd")
+        self._dateEdit.setCalendarPopup(True)
+        self._dateEdit.setFixedHeight(25)
+        self._stack.addWidget(self._dateEdit)
+        self._modeCombo.currentIndexChanged.connect(
+            lambda i: self._stack.setCurrentIndex(i)
+        )
+        layout.addWidget(self._modeCombo)
+        layout.addWidget(self._stack)
+        layout.addStretch()
+
+    _RE_DATE_ADD_CURRENT = re.compile(
+        r'^date_add\(CURRENT_DATE\(\),\s*(-?\d+)\)$', re.IGNORECASE
+    )
+
+    def getValue(
+        self
+    ) -> str:
+
+        mode = self._modeCombo.currentData()
+        if mode == "relative":
+            idx = self._relCombo.currentIndex()
+            if idx in self._dynamicItems:
+                return self._dynamicItems[idx]
+            return self._relCombo.currentText()
+        return self._dateEdit.date().toString("yyyy-MM-dd")
+
+
+    def setValue(
+        self,
+        expr: str
+    ):
+
+        s = expr.strip()
+        up = s.upper()
+        if up == "CURRENT_DATE()":
+            self._modeCombo.setCurrentIndex(0)
+            self._relCombo.setCurrentIndex(2)
+            return
+        m_add = self._RE_DATE_ADD_CURRENT.match(up)
+        if m_add:
+            n = int(m_add.group(1))
+            _OFFSET_IDX = {-2: 0, -1: 1, 0: 2, 1: 3, 2: 4}
+            idx = _OFFSET_IDX.get(n)
+            if idx is not None:
+                self._modeCombo.setCurrentIndex(0)
+                self._relCombo.setCurrentIndex(idx)
+                return
+            label = f"{n}天后" if n >= 0 else f"{-n}天前"
+            raw = f"CURRENT_DATE {'+' if n >= 0 else '-'} {abs(n)}"
+            self._modeCombo.setCurrentIndex(0)
+            for ci in range(self._relCombo.count()):
+                if ci in self._dynamicItems and self._dynamicItems[ci] == raw:
+                    self._relCombo.setCurrentIndex(ci)
+                    return
+            idx = self._relCombo.count()
+            self._relCombo.addItem(label)
+            self._dynamicItems[idx] = raw
+            self._relCombo.setCurrentIndex(idx)
+            return
+        m_date_ctor = re.match(r"^DATE\((\d+),\s*(\d+),\s*(\d+)\)$", up)
+        if m_date_ctor:
+            self._modeCombo.setCurrentIndex(1)
+            self._dateEdit.setDate(QDate(
+                int(m_date_ctor.group(1)),
+                int(m_date_ctor.group(2)),
+                int(m_date_ctor.group(3)),
+            ))
+            return
+        m_date = re.match(r'^"(\d{4}-\d{2}-\d{2})"$', s)
+        if m_date:
+            self._modeCombo.setCurrentIndex(1)
+            parts = m_date.group(1).split("-")
+            self._dateEdit.setDate(QDate(int(parts[0]), int(parts[1]), int(parts[2])))
+
+
+class _TimeInputContainer(QWidget):
+
+    def __init__(
+        self,
+        parent = None
+    ):
+
+        super().__init__(parent)
+        self._timeEdit = QTimeEdit(self)
+        self._timeEdit.setDisplayFormat("HH:mm")
+        self._timeEdit.setFixedHeight(25)
+
+        layout = QHBoxLayout(self)
+        layout.setContentsMargins(0, 0, 0, 0)
+        layout.addWidget(self._timeEdit)
+
+
+    def getValue(
+        self
+    ) -> str:
+
+        return self._timeEdit.time().toString("HH:mm")
+
+
+    def setValue(
+        self,
+        expr: str
+    ):
+
+        s = expr.strip()
+        up = s.upper()
+        m_time_ctor = re.match(r"^TIME\((\d+),\s*(\d+)\)$", up)
+        if m_time_ctor:
+            self._timeEdit.setTime(QTime(
+                int(m_time_ctor.group(1)),
+                int(m_time_ctor.group(2)),
+            ))
+            return
+        m = re.match(r'^"(\d{1,2}:\d{2})"$', s)
+        if m:
+            parts = m.group(1).split(":")
+            self._timeEdit.setTime(QTime(int(parts[0]), int(parts[1])))
+
+
+class _DateOffsetContainer(QWidget):
+
+    def __init__(
+        self,
+        parent = None
+    ):
+
+        super().__init__(parent)
+        self._spinBox = QSpinBox(self)
+        self._spinBox.setRange(0, 99999)
+        self._spinBox.setFixedHeight(25)
+        self._unitCombo = QComboBox(self)
+        for display, data in DATE_OFFSET_UNITS:
+            self._unitCombo.addItem(display, data)
+        self._unitCombo.setFixedHeight(25)
+
+        layout = QHBoxLayout(self)
+        layout.setContentsMargins(0, 0, 0, 0)
+        layout.setSpacing(4)
+        layout.addWidget(self._spinBox)
+        layout.addWidget(self._unitCombo)
+        layout.addStretch()
+
+
+    def getValue(
+        self
+    ) -> str:
+
+        return str(self.getOffsetDays())
+
+
+    def setValue(
+        self,
+        expr: str
+    ):
+
+        s = expr.strip().lstrip("+")
+        try:
+            self._spinBox.setValue(int(s))
+        except ValueError:
+            pass
+
+
+    def getOffsetDays(
+        self
+    ) -> int:
+
+        val = self._spinBox.value()
+        unit = self._unitCombo.currentData()
+        if unit == "weeks":
+            return val * 7
+        if unit == "months":
+            return val * 30
+        if unit == "years":
+            return val * 365
+        return val
+
+
+    def getRawValue(
+        self
+    ) -> str:
+
+        return str(self._spinBox.value())
+
+
+class _TimeOffsetContainer(QWidget):
+
+    def __init__(
+        self,
+        parent = None
+    ):
+
+        super().__init__(parent)
+        self._spinBox = QSpinBox(self)
+        self._spinBox.setRange(0, 99999)
+        self._spinBox.setSuffix(" 小时")
+        self._spinBox.setFixedHeight(25)
+
+        layout = QHBoxLayout(self)
+        layout.setContentsMargins(0, 0, 0, 0)
+        layout.addWidget(self._spinBox)
+
+
+    def getValue(
+        self
+    ) -> str:
+
+        return str(self.getOffsetHours())
+
+
+    def setValue(
+        self,
+        expr: str
+    ):
+
+        s = expr.strip().lstrip("+")
+        try:
+            self._spinBox.setValue(int(s))
+        except ValueError:
+            pass
+
+
+    def getOffsetHours(
+        self
+    ) -> int:
+
+        return self._spinBox.value()
+
+
+    def getRawValue(
+        self
+    ) -> str:
+
+        return str(self._spinBox.value())
+
+
+def getValueFromWidget(
+    w: QWidget
+) -> str:
+
+    if hasattr(w, "getValue"):
+        return w.getValue()
+    if isinstance(w, QTimeEdit):
+        return w.time().toString("HH:mm")
+    if isinstance(w, QDateEdit):
+        return w.date().toString("yyyy-MM-dd")
+    if isinstance(w, QComboBox):
+        return w.currentData() or w.currentText()
+    if isinstance(w, QSpinBox):
+        return str(w.value())
+    if isinstance(w, QDoubleSpinBox):
+        return str(w.value())
+    if isinstance(w, QLineEdit):
+        return w.text()
+    return ""
+
+
+def setWidgetValue(
+    w: QWidget,
+    var_type: str,
+    expr: str
+):
+    """
+        Set a widget's value from a Lua script expression.
+    """
+
+    if hasattr(w, "setValue"):
+        w.setValue(expr)
+        return
+    s = expr.strip()
+    up = s.upper()
+    if isinstance(w, QTimeEdit):
+        m_time_ctor = re.match(r"^TIME\((\d+),\s*(\d+)\)$", up)
+        if m_time_ctor:
+            w.setTime(QTime(int(m_time_ctor.group(1)), int(m_time_ctor.group(2))))
+        else:
+            m = re.match(r'^"(\d{1,2}:\d{2})"$', s)
+            if m:
+                parts = m.group(1).split(":")
+                w.setTime(QTime(int(parts[0]), int(parts[1])))
+    elif isinstance(w, QDateEdit):
+        m_date_ctor = re.match(r"^DATE\((\d+),\s*(\d+),\s*(\d+)\)$", up)
+        if m_date_ctor:
+            w.setDate(QDate(
+                int(m_date_ctor.group(1)),
+                int(m_date_ctor.group(2)),
+                int(m_date_ctor.group(3)),
+            ))
+        else:
+            m = re.match(r'^"(\d{4}-\d{2}-\d{2})"$', s)
+            if m:
+                parts = m.group(1).split("-")
+                w.setDate(QDate(int(parts[0]), int(parts[1]), int(parts[2])))
+    elif isinstance(w, QComboBox):
+        for i in range(w.count()):
+            d = w.itemData(i)
+            if d is not None:
+                if str(d).upper() == up:
+                    w.setCurrentIndex(i)
+                    return
+            if w.itemText(i).upper() == up:
+                w.setCurrentIndex(i)
+                return
+    elif isinstance(w, QSpinBox):
+        try:
+            w.setValue(int(expr))
+        except ValueError:
+            pass
+    elif isinstance(w, QDoubleSpinBox):
+        try:
+            w.setValue(float(expr))
+        except ValueError:
+            pass
+    elif isinstance(w, QLineEdit):
+        inner = expr.strip()
+        if inner.startswith('"') and inner.endswith('"'):
+            inner = inner[1:-1].replace('\\"', '"')
+        w.setText(inner)
+
+
+def encodeValueStr(
+    raw_value: str,
+    var_type: str
+) -> str:
+    """
+        Encode a raw widget value as a Lua expression.
+
+        Arithmetic expressions (A + B) are passed through for numeric types;
+        Date/Time arithmetic is translated to ``date_add()`` / ``time_add()`` calls.
+    """
+
+    if var_type in ("Date", "Time"):
+        return _encodeDateOrTime(str(raw_value), var_type)
+    if isinstance(raw_value, bool):
+        return "true" if raw_value else "false"
+    s = str(raw_value)
+    if isArithExpr(s):
+        return s
+    if var_type == "Boolean":
+        up = s.upper().strip()
+        if up in ("TRUE", "FALSE"):
+            return up.lower()
+        return "true" if raw_value else "false"
+    if var_type == "String":
+        escaped = s.replace("\\", "\\\\").replace('"', '\\"')
+        return f'"{escaped}"'
+    return s
+
+
+def _encodeDateOrTime(
+    raw_value: str,
+    var_type: str
+) -> str:
+    """
+        Translate a date/time widget value into a Lua expression.
+    """
+
+    s = raw_value.strip()
+    up = s.upper()
+    m_arith_spaced = re.match(r'^(.+?)\s+([+-])\s+(.+)$', s)
+    m_arith_nospace = re.match(r'^([A-Za-z_]\w*)([+-])(\d+|[A-Za-z_]\w*)$', s)
+    m_arith = m_arith_spaced or m_arith_nospace
+    if m_arith:
+        left = m_arith.group(1).strip().upper()
+        sign = m_arith.group(2)
+        right = m_arith.group(3).strip()
+        operand = right if sign == "+" else f"-{right}"
+        if left == "CURRENT_DATE":
+            return f"date_add(CURRENT_DATE(), {operand})"
+        if left == "CURRENT_TIME":
+            return f"time_add(CURRENT_TIME(), {operand})"
+        if var_type == "Date":
+            return f"date_add({left}, {operand})"
+        if var_type == "Time":
+            return f"time_add({left}, {operand})"
+        return f"{left} {sign} {right}"
+    if up == "CURRENT_DATE":
+        return "CURRENT_DATE()"
+    if up == "CURRENT_TIME":
+        return "CURRENT_TIME()"
+    _REL_MAP = {
+        "前天": "date_add(CURRENT_DATE(), -2)",
+        "昨天": "date_add(CURRENT_DATE(), -1)",
+        "今天": "CURRENT_DATE()",
+        "明天": "date_add(CURRENT_DATE(), 1)",
+        "后天": "date_add(CURRENT_DATE(), 2)",
+    }
+    if s in _REL_MAP:
+        return _REL_MAP[s]
+    if var_type == "Date":
+        m_date = re.match(r"^(\d{4})-(\d{2})-(\d{2})$", s)
+        if m_date:
+            y, m, d = int(m_date.group(1)), int(m_date.group(2)), int(m_date.group(3))
+            return f"date({y}, {m}, {d})"
+    if var_type == "Time":
+        m_time = re.match(r"^(\d{1,2}):(\d{2})$", s)
+        if m_time:
+            h, m = int(m_time.group(1)), int(m_time.group(2))
+            return f"time({h}, {m})"
+    if re.match(r"^[+-]?\d+$", s):
+        return s
+    if re.match(r"^[A-Za-z_]\w*$", s):
+        return s
+    return f'"{s}"'
+
+
+def stripOuterParens(
+    s: str
+) -> str:
+
+    s = s.strip()
+    if s.startswith("(") and s.endswith(")"):
+        depth = 0
+        for i, ch in enumerate(s):
+            if ch == "(":
+                depth += 1
+            elif ch == ")":
+                depth -= 1
+                if depth == 0 and i < len(s) - 1:
+                    return s
+        return s[1:-1].strip()
+    return s
+
+
+# Pre-compiled patterns for detecting arithmetic expressions (A + B / A - B)
+_RE_ARITH_SPACED = re.compile(r'^(.+?)\s+([+-])\s+(.+)$')
+_RE_ARITH_NOSPACE = re.compile(r'^([A-Za-z_]\w*)([+-])(\d+|[A-Za-z_]\w*)$')
+
+
+def isArithExpr(
+    expr: str
+) -> bool:
+    """
+        Return True if expr looks like a two-operand arithmetic expression (A ± B).
+    """
+
+    s = expr.strip()
+    return bool(_RE_ARITH_SPACED.match(s) or _RE_ARITH_NOSPACE.match(s))
+
+
+def isVarReference(
+    expr: str
+) -> bool:
+    """
+        Return True if *expr* looks like a variable name reference
+        (as opposed to a literal value or function call).
+    """
+
+    s = expr.strip()
+    up = s.upper()
+    if up in ("TRUE", "FALSE"):
+        return False
+    if re.match(r"^DATE\(|^TIME\(|^DATE_ADD\(|^TIME_ADD\(|^CURRENT_DATE\(|^CURRENT_TIME\(|^CURRENT_", up):
+        return False
+    if up.startswith('"') or up.startswith("'"):
+        return False
+    if re.match(r"^[+-]?\d", s):
+        return False
+    if isArithExpr(s):
+        return False
+    return bool(re.match(r"^[A-Z_][A-Z0-9_]*$", up))
+
+
+def findOperatorIn(
+    text: str,
+    operators: list
+) -> tuple[int, str] | None:
+
+    for op in operators:
+        op_upper = op.upper()
+        start = 0
+        while True:
+            idx = text.upper().find(op_upper, start)
+            if idx < 0:
+                break
+            if _isInsideLiteral(text, idx):
+                start = idx + 1
+                continue
+            return (idx, op)
+    return None
+
+
+def _isInsideLiteral(
+    text: str,
+    pos: int
+) -> bool:
+
+    in_single = False
+    in_double = False
+    for i, ch in enumerate(text):
+        if i >= pos:
+            break
+        if ch == "'" and not in_double:
+            in_single = not in_single
+        elif ch == '"' and not in_single:
+            in_double = not in_double
+    return in_single or in_double

src/gui/ALAutoScriptOrchDialog/_widgets.py

@@ -0,0 +1,474 @@
+# -*- coding: utf-8 -*-
+"""
+Copyright (c) 2026 KenanZhu.
+All rights reserved.
+
+This software is provided "as is", without any warranty of any kind.
+You may use, modify, and distribute this file under the terms of the MIT License.
+See the LICENSE file for details.
+"""
+"""
+    Widget components for the AutoScript orchestration dialog.
+"""
+from PySide6.QtCore import Slot
+from PySide6.QtWidgets import (
+    QComboBox,
+    QFrame,
+    QHBoxLayout,
+    QLabel,
+    QPushButton,
+    QSizePolicy,
+    QStackedWidget
+)
+
+from gui.ALAutoScriptOrchDialog._helpers import (
+    ACTION_TYPES,
+    ARITH_TYPES,
+    COMPARE_OPERATORS,
+    LOGIC_OPERATORS,
+    PRESET_VARIABLES,
+    VAR_TYPE_ORDER,
+    encodeValueStr,
+    getValueFromWidget,
+    makeComboWidget,
+    makeLabel,
+    makeOffsetWidget,
+    makeValueWidget,
+    makeVarRefCombo,
+)
+
+
+class ConditionRowFrame(QFrame):
+
+    def __init__(
+        self,
+        varMgr,
+        parentBlockIndex: int = 0,
+        isFirst: bool = False,
+        parent = None
+    ):
+
+        super().__init__(parent)
+        self._varMgr = varMgr
+        self._blockIndex = parentBlockIndex
+        self._isFirst = isFirst
+        self._isBoolMode = False
+        self._rawRhsExpr = ""
+
+        self.setupUi()
+        self.connectSignals()
+
+
+    def setupUi(
+        self
+    ):
+
+        self.setUpdatesEnabled(False)
+        self.setFrameShape(QFrame.StyledPanel)
+        self.setFrameShadow(QFrame.Raised)
+        self.setFixedHeight(32)
+        layout = QHBoxLayout(self)
+        layout.setContentsMargins(2, 2, 2, 2)
+        layout.setSpacing(4)
+        if self._isFirst:
+            self.logicCombo = None
+        else:
+            self.logicCombo = makeComboWidget(LOGIC_OPERATORS, min_width=110, parent=self)
+            layout.addWidget(self.logicCombo)
+        self.leftVarCombo = QComboBox(self)
+        self.leftVarCombo.setFixedHeight(25)
+        self.leftVarCombo.setMinimumWidth(120)
+        self.leftVarCombo.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed)
+        self.populateLeftVarCombo()
+        layout.addWidget(self.leftVarCombo)
+        self.opCombo = makeComboWidget(COMPARE_OPERATORS, min_width=80, parent=self)
+        layout.addWidget(self.opCombo)
+        self._compTypeCombo = makeComboWidget([
+            ("特定值", "literal"),
+            ("变量", "variable"),
+        ], min_width=70, parent=self)
+        layout.addWidget(self._compTypeCombo)
+        self.rhsStack = QStackedWidget(self)
+        self.rhsStack.setFixedHeight(25)
+        self.literalStack = QStackedWidget(self)
+        self.literalStack.setFixedHeight(25)
+        self.literalWidgets = {}
+        for vt in VAR_TYPE_ORDER:
+            w = makeValueWidget(vt, self.literalStack)
+            self.literalWidgets[vt] = w
+            self.literalStack.addWidget(w)
+        self.literalStack.setCurrentWidget(self.literalWidgets.get("String"))
+        self.rhsStack.addWidget(self.literalStack)
+        self.rhsVarCombo = makeVarRefCombo(self)
+        self.rhsStack.addWidget(self.rhsVarCombo)
+        self.rhsStack.setCurrentIndex(0)
+        layout.addWidget(self.rhsStack)
+        if not self._isFirst:
+            self.deleteBtn = QPushButton("×", self)
+            self.deleteBtn.setFixedSize(25, 25)
+            self.deleteBtn.setStyleSheet("color: red; font-weight: bold;")
+            layout.addWidget(self.deleteBtn)
+        else:
+            self.deleteBtn = None
+        layout.addStretch()
+        self.setUpdatesEnabled(True)
+
+
+    def populateLeftVarCombo(
+        self
+    ):
+
+        wasBool = self._isBoolMode
+        boolName = None
+        if wasBool:
+            data = self.leftVarCombo.currentData()
+            if data:
+                boolName = data[0]
+        self._varMgr.populateCombo(self.leftVarCombo)
+        # Append boolean literal sentinels at the end
+        self.leftVarCombo.insertSeparator(self.leftVarCombo.count())
+        self.leftVarCombo.addItem("true", ("true", "Boolean"))
+        self.leftVarCombo.addItem("false", ("false", "Boolean"))
+        if wasBool and boolName:
+            for ci in range(self.leftVarCombo.count()):
+                d = self.leftVarCombo.itemData(ci)
+                if d and d[0] == boolName:
+                    self.leftVarCombo.setCurrentIndex(ci)
+                    break
+
+
+    def populateRhsVarCombo(
+        self
+    ):
+
+        self._varMgr.populateCombo(self.rhsVarCombo)
+
+
+    def connectSignals(
+        self
+    ):
+
+        self.leftVarCombo.currentIndexChanged.connect(self.onLeftVarChanged)
+        self._compTypeCombo.currentIndexChanged.connect(self.onCompTypeChanged)
+
+    @Slot(int)
+    def onLeftVarChanged(
+        self,
+        idx
+    ):
+
+        self._rawRhsExpr = ""
+        if idx < 0:
+            return
+        data = self.leftVarCombo.itemData(idx)
+        if not data:
+            return
+        name, vartype = data
+        isBool = name in ("true", "false")
+        self._isBoolMode = isBool
+        self.opCombo.setVisible(not isBool)
+        self._compTypeCombo.setVisible(not isBool)
+        self.rhsStack.setVisible(not isBool)
+        if not isBool:
+            self.updateRhsLiteralWidget(vartype)
+
+
+    def updateRhsLiteralWidget(
+        self,
+        vartype: str
+    ):
+
+        if vartype not in self.literalWidgets:
+            vartype = "String"
+        self.literalStack.setCurrentWidget(self.literalWidgets[vartype])
+
+    @Slot(int)
+    def onCompTypeChanged(
+        self,
+        idx
+    ):
+
+        self._rawRhsExpr = ""
+        isVar = (self._compTypeCombo.currentData() == "variable")
+        self.rhsStack.setCurrentIndex(1 if isVar else 0)
+        if isVar:
+            self.populateRhsVarCombo()
+
+
+    def getLogic(
+        self
+    ) -> str:
+
+        return self.logicCombo.currentData() if self.logicCombo else ""
+
+
+    def toConditionText(
+        self
+    ) -> str:
+
+        data = self.leftVarCombo.currentData()
+        if self._isBoolMode and data:
+            return data[0]
+        if not data:
+            return ""
+        name, vartype = data
+        # CURRENT_DATE / CURRENT_TIME are Lua functions — call them, not reference them
+        if name in ("CURRENT_DATE", "CURRENT_TIME"):
+            name = f"{name}()"
+        opSym = self.opCombo.currentData()
+        if self._rawRhsExpr:
+            return f"{name} {opSym} {self._rawRhsExpr}"
+        isVarRef = (self._compTypeCombo.currentData() == "variable")
+        if isVarRef:
+            rd = self.rhsVarCombo.currentData()
+            if rd:
+                rhsName = rd[0]
+                if rhsName in ("CURRENT_DATE", "CURRENT_TIME"):
+                    rhsName = f"{rhsName}()"
+                return f"{name} {opSym} {rhsName}"
+            rhsText = self.rhsVarCombo.currentText().strip()
+            if rhsText:
+                return f"{name} {opSym} {rhsText}"
+            return ""
+        w = self.literalWidgets.get(vartype)
+        if w:
+            rawVal = getValueFromWidget(w)
+            encoded = encodeValueStr(rawVal, vartype)
+            return f"{name} {opSym} {encoded}"
+        return ""
+
+
+    def refreshVarCombos(
+        self
+    ):
+
+        self.populateLeftVarCombo()
+        self.populateRhsVarCombo()
+
+class ActionStepFrame(QFrame):
+
+    def __init__(
+        self,
+        varMgr,
+        parentBlockIndex: int = 0,
+        parent = None
+    ):
+
+        super().__init__(parent)
+        self._varMgr = varMgr
+        self._blockIndex = parentBlockIndex
+        self._currentTargetType = "String"
+
+        self.setupUi()
+        self.connectSignals()
+
+
+    def setupUi(
+        self
+    ):
+
+        self.setUpdatesEnabled(False)
+        self.setFrameShape(QFrame.StyledPanel)
+        self.setFrameShadow(QFrame.Raised)
+        self.setFixedHeight(35)
+        layout = QHBoxLayout(self)
+        layout.setContentsMargins(2, 2, 2, 2)
+        layout.setSpacing(4)
+        self.opTypeCombo = makeComboWidget(ACTION_TYPES, min_width=70, parent=self)
+        layout.addWidget(self.opTypeCombo)
+        layout.addWidget(makeLabel("设置", self))
+        self.targetCombo = QComboBox(self)
+        self.targetCombo.setFixedHeight(25)
+        self.targetCombo.setMinimumWidth(120)
+        self.buildTargetCombo()
+        layout.addWidget(self.targetCombo)
+        layout.addWidget(makeLabel("为", self))
+        self.valueSrcCombo = makeComboWidget([
+            ("特定值", "literal"),
+            ("变量", "variable"),
+        ], min_width=70, parent=self)
+        layout.addWidget(self.valueSrcCombo)
+        self.valueStack = QStackedWidget(self)
+        self.valueStack.setFixedHeight(25)
+        self.initValueStacks()
+        layout.addWidget(self.valueStack)
+        self.existingVarCombo = makeVarRefCombo(self)
+        self.existingVarCombo.setVisible(False)
+        layout.addWidget(self.existingVarCombo)
+        self.deleteBtn = QPushButton("×", self)
+        self.deleteBtn.setFixedSize(25, 25)
+        self.deleteBtn.setStyleSheet("color: red; font-weight: bold;")
+        layout.addWidget(self.deleteBtn)
+        self.setUpdatesEnabled(True)
+
+
+    def buildTargetCombo(
+        self
+    ):
+
+        self.targetCombo.blockSignals(True)
+        self.targetCombo.clear()
+        for p in PRESET_VARIABLES:
+            if p["name"] in ("CURRENT_TIME", "CURRENT_DATE"):
+                continue
+            info = self._varMgr.getInfoByName(p["name"])
+            if info:
+                self.targetCombo.addItem(
+                    info["display"],
+                    (info["name"], info["type"])
+                )
+        self.targetCombo.blockSignals(False)
+
+
+    def initValueStacks(
+        self
+    ):
+
+        self._literalWidgets = {}
+        self._offsetWidgets = {}
+        for vt in VAR_TYPE_ORDER:
+            self._literalWidgets[vt] = makeValueWidget(vt, self.valueStack)
+            self.valueStack.addWidget(self._literalWidgets[vt])
+            if vt in ARITH_TYPES:
+                self._offsetWidgets[vt] = makeOffsetWidget(vt, self.valueStack)
+                self.valueStack.addWidget(self._offsetWidgets[vt])
+            else:
+                lbl = QLabel("(不支持该操作)", self.valueStack)
+                lbl.setFixedHeight(25)
+                self._offsetWidgets[vt] = lbl
+                self.valueStack.addWidget(lbl)
+
+
+    def connectSignals(
+        self
+    ):
+
+        self.opTypeCombo.currentIndexChanged.connect(self.onOpTypeChanged)
+        self.targetCombo.currentIndexChanged.connect(self.onTargetChanged)
+        self.valueSrcCombo.currentIndexChanged.connect(self.onValueSrcChanged)
+
+    @Slot(int)
+    def onTargetChanged(
+        self,
+        idx
+    ):
+
+        if idx < 0:
+            return
+        data = self.targetCombo.itemData(idx)
+        if not data:
+            return
+        _, vartype = data
+        self._currentTargetType = vartype
+        self.updateRHSWidget()
+        self.onValueSrcChanged(self.valueSrcCombo.currentIndex())
+
+    @Slot(int)
+    def onOpTypeChanged(
+        self,
+        idx
+    ):
+
+        self.updateRHSWidget()
+
+
+    def updateRHSWidget(
+        self
+    ):
+
+        op = self.opTypeCombo.currentData()
+        isArith = (op in ("add", "sub"))
+        actualType = self._currentTargetType
+        if isArith and actualType in self._offsetWidgets:
+            self.valueStack.setCurrentWidget(self._offsetWidgets[actualType])
+        elif actualType in self._literalWidgets:
+            self.valueStack.setCurrentWidget(self._literalWidgets[actualType])
+        else:
+            self.valueStack.setCurrentWidget(self._literalWidgets.get("String"))
+
+    @Slot(int)
+    def onValueSrcChanged(
+        self,
+        idx
+    ):
+
+        isVar = (self.valueSrcCombo.currentData() == "variable")
+        self.valueStack.setVisible(not isVar)
+        self.existingVarCombo.setVisible(isVar)
+        if isVar:
+            self._varMgr.populateCombo(self.existingVarCombo)
+        else:
+            self.updateRHSWidget()
+
+
+    def getTargetName(
+        self
+    ) -> str:
+
+        data = self.targetCombo.currentData()
+        return data[0] if data else ""
+
+
+    def toScriptLine(
+        self
+    ) -> str:
+        """
+            Generate a single line of Lua script from the current widget state.
+        """
+
+        target = self.getTargetName()
+        op = self.opTypeCombo.currentData()
+        if op == "pass":
+            return "    -- pass"
+        if not target:
+            return ""
+        rawVal = self._getValueRaw()
+        vartype = self._currentTargetType
+        if op == "set":
+            encoded = encodeValueStr(rawVal, vartype)
+            return f"    {target} = {encoded}"
+        elif op == "add":
+            if vartype == "Date" and hasattr(self.valueStack.currentWidget(), "getOffsetDays"):
+                days = self.valueStack.currentWidget().getOffsetDays()
+                return f"    {target} = date_add({target}, {days})"
+            if vartype == "Time" and hasattr(self.valueStack.currentWidget(), "getOffsetHours"):
+                hours = self.valueStack.currentWidget().getOffsetHours()
+                return f"    {target} = time_add({target}, {hours})"
+            return f"    {target} = {target} + {rawVal}"
+        elif op == "sub":
+            if vartype == "Date" and hasattr(self.valueStack.currentWidget(), "getOffsetDays"):
+                days = self.valueStack.currentWidget().getOffsetDays()
+                return f"    {target} = date_add({target}, -{days})"
+            if vartype == "Time" and hasattr(self.valueStack.currentWidget(), "getOffsetHours"):
+                hours = self.valueStack.currentWidget().getOffsetHours()
+                return f"    {target} = time_add({target}, -{hours})"
+            return f"    {target} = {target} - {rawVal}"
+        return ""
+
+
+    def _getValueRaw(
+        self
+    ) -> str:
+
+        if self.valueSrcCombo.currentData() == "variable":
+            data = self.existingVarCombo.currentData()
+            return data[0] if data else ""
+        w = self.valueStack.currentWidget()
+        if w:
+            return getValueFromWidget(w)
+        return ""
+
+
+    def refreshVarCombos(
+        self
+    ):
+
+        currentData = self.targetCombo.currentData()
+        self.buildTargetCombo()
+        if currentData:
+            for i in range(self.targetCombo.count()):
+                d = self.targetCombo.itemData(i)
+                if d and d[0] == currentData[0]:
+                    self.targetCombo.setCurrentIndex(i)
+                    break
+        self._varMgr.populateCombo(self.existingVarCombo)

src/gui/ALAutoScriptPrevDialog.py

@@ -1,226 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-Copyright (c) 2026 KenanZhu.
-All rights reserved.
-
-This software is provided "as is", without any warranty of any kind.
-You may use, modify, and distribute this file under the terms of the MIT License.
-See the LICENSE file for details.
-"""
-
-from PySide6.QtCore import Slot
-
-from PySide6.QtGui import (
-    QSyntaxHighlighter, QTextCharFormat, QColor, QFont, QIcon
-)
-from PySide6.QtWidgets import (
-    QDialog, QVBoxLayout, QHBoxLayout, QPlainTextEdit,
-    QDialogButtonBox, QPushButton, QLabel, QApplication, QStyle
-)
-
-
-class ALScriptHighlighter(QSyntaxHighlighter):
-
-    def __init__(
-        self,
-        parent=None
-    ):
-
-        super().__init__(parent)
-        self._rules = []
-
-        keywordFmt = QTextCharFormat()
-        keywordFmt.setForeground(QColor("#316BFF"))
-        keywordFmt.setFontWeight(QFont.Weight.Bold)
-        for kw in ["IF", "ELSE IF", "ELSE", "ENDIF", "END IF",
-                    "SET", "PASS", "THEN"]:
-            pattern = r"\b" + kw.replace(" ", r"\s+") + r"\b"
-            self._rules.append((pattern, keywordFmt))
-        literalFmt = QTextCharFormat()
-        literalFmt.setForeground(QColor("#C2185B"))
-        literalFmt.setFontWeight(QFont.Weight.Bold)
-        for lit in [".TRUE.", ".FALSE."]:
-            self._rules.append((r"\b" + lit.replace(".", r"\.") + r"\b", literalFmt))
-        opFmt = QTextCharFormat()
-        opFmt.setForeground(QColor("#9C27B0"))
-        for op in [r"\.EQ\.", r"\.NEQ\.", r"\.BGT\.", r"\.BLT\.",
-                   r"\.BGE\.", r"\.BLE\.", r"\.ADD\.", r"\.SUB\."]:
-            self._rules.append((op, opFmt))
-        varFmt = QTextCharFormat()
-        varFmt.setForeground(QColor("#E65100"))
-        for var in ["RESERVE_BEGIN_TIME", "RESERVE_END_TIME",
-                    "RESERVE_DATE", "USERNAME", "USER_ENABLE",
-                    "PRIORITY", "CURRENT_TIME", "CURRENT_DATE"]:
-            self._rules.append((r"\b" + var + r"\b", varFmt))
-        funcFmt = QTextCharFormat()
-        funcFmt.setForeground(QColor("#2E7D32"))
-        self._rules.append((r"\bTIME\([^)]+\)", funcFmt))
-        self._rules.append((r"\bDATE\([^)]+\)", funcFmt))
-        strFmt = QTextCharFormat()
-        strFmt.setForeground(QColor("#388E3C"))
-        self._rules.append((r"'[^']*'", strFmt))
-        numFmt = QTextCharFormat()
-        numFmt.setForeground(QColor("#D32F2F"))
-        self._rules.append((r"\b\d+\b", numFmt))
-        commentFmt = QTextCharFormat()
-        commentFmt.setForeground(QColor("#999999"))
-        commentFmt.setFontItalic(True)
-        self._rules.append((r"//[^\n]*", commentFmt))
-
-
-    def highlightBlock(
-        self,
-        text
-    ):
-
-        import re
-        for pattern, fmt in self._rules:
-            for match in re.finditer(pattern, text, re.IGNORECASE):
-                start = match.start()
-                length = match.end() - match.start()
-                self.setFormat(start, length, fmt)
-
-
-class ALAutoScriptPreviewDialog(QDialog):
-
-    def __init__(
-        self,
-        parent=None,
-        script: str = ""
-    ):
-
-        super().__init__(parent)
-        self.__fontSize = 13
-
-        self.modifyUi()
-        self.connectSignals()
-
-        self._textEdit.setPlainText(script)
-        self._highlighter = ALScriptHighlighter(
-            self._textEdit.document()
-        )
-
-
-    def modifyUi(
-        self
-    ):
-
-        self.setWindowTitle("AutoScript 预览 - AutoLibrary")
-        self.setMinimumSize(520, 360)
-
-        layout = QVBoxLayout(self)
-        toolbarLayout = QHBoxLayout()
-        self._zoomInBtn = QPushButton("＋")
-        self._zoomInBtn.setFixedSize(30, 25)
-        self._zoomOutBtn = QPushButton("－")
-        self._zoomOutBtn.setFixedSize(30, 25)
-        self._zoomResetBtn = QPushButton(
-            QApplication.style().standardIcon(
-                QStyle.StandardPixmap.SP_BrowserReload
-            ), ""
-        )
-        self._zoomResetBtn.setFixedSize(30, 25)
-        self._zoomResetBtn.setToolTip("重置缩放")
-        self._zoomLabel = QLabel(f"{self.__fontSize}px")
-        self._zoomLabel.setFixedHeight(25)
-        toolbarLayout.addWidget(self._zoomInBtn)
-        toolbarLayout.addWidget(self._zoomOutBtn)
-        toolbarLayout.addWidget(self._zoomResetBtn)
-        toolbarLayout.addWidget(self._zoomLabel)
-        toolbarLayout.addStretch()
-        self._copyBtn = QPushButton(
-            QApplication.style().standardIcon(
-                QStyle.StandardPixmap.SP_FileDialogDetailedView
-            ), ""
-        )
-        self._copyBtn.setFixedSize(30, 25)
-        self._copyBtn.setToolTip("复制脚本")
-        toolbarLayout.addWidget(self._copyBtn)
-        layout.addLayout(toolbarLayout)
-        self._textEdit = QPlainTextEdit(self)
-        self._textEdit.setReadOnly(True)
-        self._textEdit.setLineWrapMode(
-            QPlainTextEdit.LineWrapMode.NoWrap
-        )
-        self._textEdit.setStyleSheet(
-            "QPlainTextEdit {"
-            "  font-family: 'Courier New', 'Consolas', monospace;"
-            "  font-size: 13px;"
-            "}"
-        )
-        layout.addWidget(self._textEdit)
-
-        self._btnBox = QDialogButtonBox(
-            QDialogButtonBox.StandardButton.Close
-        )
-        self._btnBox.button(
-            QDialogButtonBox.StandardButton.Close
-        ).setText("关闭")
-        layout.addWidget(self._btnBox)
-
-
-    def connectSignals(
-        self
-    ):
-
-        self._btnBox.rejected.connect(self.reject)
-        self._zoomInBtn.clicked.connect(self.onZoomIn)
-        self._zoomOutBtn.clicked.connect(self.onZoomOut)
-        self._zoomResetBtn.clicked.connect(self.onZoomReset)
-        self._copyBtn.clicked.connect(self.onCopy)
-
-
-    def updateFontSize(
-        self
-    ):
-
-        font = self._textEdit.font()
-        font.setPointSize(self.__fontSize)
-        self._textEdit.setFont(font)
-        self._textEdit.setStyleSheet(
-            "QPlainTextEdit {"
-            "  font-family: 'Courier New', 'Consolas', monospace;"
-            f"  font-size: {self.__fontSize}px;"
-            "}"
-        )
-        self._zoomLabel.setText(f"{self.__fontSize}px")
-
-    @Slot()
-    def onZoomIn(
-        self
-    ):
-
-        self.__fontSize = min(self.__fontSize + 2, 40)
-        self.updateFontSize()
-
-    @Slot()
-    def onZoomOut(
-        self
-    ):
-
-        self.__fontSize = max(self.__fontSize - 2, 8)
-        self.updateFontSize()
-
-    @Slot()
-    def onZoomReset(
-        self
-    ):
-
-        self.__fontSize = 13
-        self.updateFontSize()
-
-    @Slot()
-    def onCopy(
-        self
-    ):
-
-        clipboard = QApplication.clipboard()
-        clipboard.setText(self._textEdit.toPlainText())
-        original = self._copyBtn.text()
-        self._copyBtn.setText("已复制")
-        self._copyBtn.setEnabled(False)
-        from PySide6.QtCore import QTimer
-        QTimer.singleShot(2000, lambda: (
-            self._copyBtn.setText(original),
-            self._copyBtn.setEnabled(True)
-        ))

src/gui/ALConfigWidget.py

@@ -24,7 +24,8 @@ import managers.config.ConfigManager as ConfigManager
 
 from utils.JSONReader import JSONReader
 from utils.JSONWriter import JSONWriter
-from utils.ConfigUtils import ConfigUtils
+from interfaces.ConfigProvider import ConfigProvider, CfgKey
+from managers.config.ConfigUtils import ConfigUtils
 
 from gui.resources.ui.Ui_ALConfigWidget import Ui_ALConfigWidget
 from gui.ALSeatMapSelectDialog import ALSeatMapSelectDialog
@@ -43,7 +44,7 @@ class ALConfigWidget(QWidget, Ui_ALConfigWidget):
     ):
 
         super().__init__(parent)
-        self.__cfg_mgr = ConfigManager.instance()
+        self.__cfg_mgr: ConfigProvider = ConfigManager.instance()
         self.__config_paths = ConfigUtils.getAutomationConfigPaths()
         self.__config_data = {"run": {}, "user": {}}
 
@@ -985,13 +986,13 @@ class ALConfigWidget(QWidget, Ui_ALConfigWidget):
                 self.setRunConfigToWidget(data)
                 self.__config_paths["run"] = run_config_path
                 self.CurrentRunConfigEdit.setText(run_config_path)
-                paths = self.__cfg_mgr.get(ConfigManager.ConfigType.GLOBAL, "automation.run_path.paths", [])
+                paths = self.__cfg_mgr.get(CfgKey.GLOBAL.AUTOMATION.RUN_PATH.PATHS, [])
                 if run_config_path not in paths:
                     paths.append(run_config_path)
                     index = len(paths) - 1
                 else:
                     index = paths.index(run_config_path)
-                self.__cfg_mgr.set(ConfigManager.ConfigType.GLOBAL, "automation.run_path", {"current": index, "paths": paths})
+                self.__cfg_mgr.set(CfgKey.GLOBAL.AUTOMATION.RUN_PATH.ROOT, {"current": index, "paths": paths})
             else:
                 QMessageBox.warning(
                     self,
@@ -1020,13 +1021,13 @@ class ALConfigWidget(QWidget, Ui_ALConfigWidget):
                 self.setUsersToTreeWidget(data)
                 self.__config_paths["user"] = user_config_path
                 self.CurrentUserConfigEdit.setText(user_config_path)
-                paths = self.__cfg_mgr.get(ConfigManager.ConfigType.GLOBAL, "automation.user_path.paths", [])
+                paths = self.__cfg_mgr.get(CfgKey.GLOBAL.AUTOMATION.USER_PATH.PATHS, [])
                 if user_config_path not in paths:
                     paths.append(user_config_path)
                     index = len(paths) - 1
                 else:
                     index = paths.index(user_config_path)
-                self.__cfg_mgr.set(ConfigManager.ConfigType.GLOBAL, "automation.user_path", {"current": index, "paths": paths})
+                self.__cfg_mgr.set(CfgKey.GLOBAL.AUTOMATION.USER_PATH.ROOT, {"current": index, "paths": paths})
             else:
                 QMessageBox.warning(
                     self,

src/gui/ALMainWindow.py

@@ -20,7 +20,7 @@ from PySide6.QtGui import (
 )
 
 from base.MsgBase import MsgBase
-from utils.ConfigUtils import ConfigUtils
+from managers.config.ConfigUtils import ConfigUtils
 
 from gui.resources.ui.Ui_ALMainWindow import Ui_ALMainWindow
 from gui.resources import ALResource

src/gui/ALMainWorkers.py

@@ -18,7 +18,7 @@ from PySide6.QtCore import (
 from base.MsgBase import MsgBase
 from operators.AutoLib import AutoLib
 from utils.JSONReader import JSONReader
-from utils.AutoScriptEngine import AutoScriptEngine
+from autoscript import execute, registerDefaultTargetVars
 
 
 class AutoLibWorker(MsgBase, QThread):
@@ -225,7 +225,8 @@ class TimerTaskWorker(AutoLibWorker):
                 continue
             for user in group.get("users", []):
                 try:
-                    AutoScriptEngine.execute(auto_script, user)
+                    registerDefaultTargetVars()
+                    execute(auto_script, user)
                     affected_count += 1
                 except ValueError as e:
                     self._showTrace(

src/gui/ALSeatFrame.py

@@ -31,6 +31,7 @@ class ALSeatFrame(QFrame):
 
         self.setupUi()
 
+
     def setupUi(
         self
     ):
@@ -54,6 +55,7 @@ class ALSeatFrame(QFrame):
         self.Label.setAlignment(Qt.AlignCenter)
         self.Label.setGeometry(0, 0, 60, 40)
 
+
     def mousePressEvent(
         self,
         event

src/gui/ALTimerTaskAddDialog.py

@@ -17,7 +17,6 @@ from PySide6.QtGui import QDesktopServices
 from PySide6.QtWidgets import QLabel, QDialog, QWidget, QSpinBox, QHBoxLayout, QVBoxLayout, QGridLayout, QDateTimeEdit, QGroupBox, QPushButton
 
 from gui.resources.ui.Ui_ALTimerTaskAddDialog import Ui_ALTimerTaskAddDialog
-from gui.ALAutoScriptOrchDialog import ALAutoScriptOrchDialog
 from utils.TimerUtils import TimerUtils
 
 
@@ -58,6 +57,8 @@ class ALTimerTaskAddDialog(QDialog, Ui_ALTimerTaskAddDialog):
         self.TimerTypeComboBox.setCurrentIndex(0)
         self.SpecificTimerWidget = QWidget()
         self.SpecificTimerLayout = QHBoxLayout(self.SpecificTimerWidget)
+        self.SpecificTimerLayout.setContentsMargins(0, 0, 0, 0)
+        self.SpecificTimerLayout.setSpacing(5)
         self.SpecificTimerLayout.addWidget(QLabel("定时时间："))
         self.SpecificDateTimeEdit = QDateTimeEdit()
         self.SpecificDateTimeEdit.setCalendarPopup(True)
@@ -69,6 +70,8 @@ class ALTimerTaskAddDialog(QDialog, Ui_ALTimerTaskAddDialog):
 
         self.RelativeTimerWidget = QWidget()
         self.RelativeTimerLayout = QHBoxLayout(self.RelativeTimerWidget)
+        self.RelativeTimerLayout.setContentsMargins(0, 0, 0, 0)
+        self.RelativeTimerLayout.setSpacing(5)
         self.RelativeTimerLayout.addWidget(QLabel("相对时间："))
         self.RelativeDaySpinBox = QSpinBox()
         self.RelativeDaySpinBox.setMinimum(0)
@@ -98,14 +101,9 @@ class ALTimerTaskAddDialog(QDialog, Ui_ALTimerTaskAddDialog):
         self.AutoScriptLayout.setContentsMargins(3, 3, 3, 3)
         self.AutoScriptLayout.setSpacing(3)
         autoScriptBtnLayout = QHBoxLayout()
-        self.AutoScriptSetButton = QPushButton("设置指令")
+        self.AutoScriptPreviewButton = QPushButton("编辑")
-        self.AutoScriptSetButton.setMinimumHeight(25)
-        self.AutoScriptSetButton.setFixedWidth(130)
-        autoScriptBtnLayout.addWidget(self.AutoScriptSetButton)
-        self.AutoScriptPreviewButton = QPushButton("预览")
         self.AutoScriptPreviewButton.setMinimumHeight(25)
         self.AutoScriptPreviewButton.setFixedWidth(60)
-        self.AutoScriptPreviewButton.setEnabled(False)
         autoScriptBtnLayout.addWidget(self.AutoScriptPreviewButton)
         autoScriptBtnLayout.addStretch()
         self.AutoScriptHelpButton = QPushButton("?")
@@ -133,6 +131,7 @@ class ALTimerTaskAddDialog(QDialog, Ui_ALTimerTaskAddDialog):
         )
         self.AutoScriptGroupBox.setVisible(False)
         self.__auto_script = ""
+        self.__mock_target_data = None
 
 
     def loadTask(
@@ -170,7 +169,9 @@ class ALTimerTaskAddDialog(QDialog, Ui_ALTimerTaskAddDialog):
                 self.__auto_script = auto_script
                 self.AutoScriptStatusLabel.setText("已设置")
                 self.AutoScriptStatusLabel.setStyleSheet("color: #4CAF50;")
-                self.AutoScriptPreviewButton.setEnabled(True)
+            mock_data = task.get("mock_target_data")
+            if mock_data:
+                self.__mock_target_data = mock_data
         self.ConfirmButton.setText("保存")
 
 
@@ -182,7 +183,6 @@ class ALTimerTaskAddDialog(QDialog, Ui_ALTimerTaskAddDialog):
         self.ConfirmButton.clicked.connect(self.accept)
         self.TimerTypeComboBox.currentIndexChanged.connect(self.onTimerTypeComboBoxIndexChanged)
         self.RepeatCheckBox.toggled.connect(self.onRepeatCheckBoxToggled)
-        self.AutoScriptSetButton.clicked.connect(self.onSetAutoScript)
         self.AutoScriptPreviewButton.clicked.connect(self.onPreviewAutoScript)
         self.AutoScriptHelpButton.clicked.connect(self.onAutoScriptHelp)
 
@@ -218,6 +218,7 @@ class ALTimerTaskAddDialog(QDialog, Ui_ALTimerTaskAddDialog):
             task_data["status"] = ALTimerTaskStatus.PENDING
             task_data["executed"] = False
             task_data["repeat_auto_script"] = self.__auto_script
+            task_data["mock_target_data"] = self.__mock_target_data
         else:
             task_data = {
                 "name": name,
@@ -230,6 +231,7 @@ class ALTimerTaskAddDialog(QDialog, Ui_ALTimerTaskAddDialog):
                 "executed": False,
                 "repeat": self.RepeatCheckBox.isChecked(),
                 "repeat_auto_script": self.__auto_script,
+                "mock_target_data": self.__mock_target_data,
             }
 
         repeat = self.RepeatCheckBox.isChecked()
@@ -291,28 +293,19 @@ class ALTimerTaskAddDialog(QDialog, Ui_ALTimerTaskAddDialog):
         self.AutoScriptGroupBox.setVisible(checked)
 
     @Slot()
-    def onSetAutoScript(self):
+    def onPreviewAutoScript(self):
-        dlg = ALAutoScriptOrchDialog(self, existingScript=self.__auto_script)
+        from gui.ALAutoScriptEditDialog import ALAutoScriptEditDialog
+        dlg = ALAutoScriptEditDialog(self, self.__auto_script, self.__mock_target_data)
         if dlg.exec() == QDialog.DialogCode.Accepted:
             script = dlg.getScript()
             self.__auto_script = script
+            self.__mock_target_data = dlg.getMockData()
             if script:
                 self.AutoScriptStatusLabel.setText("已设置")
                 self.AutoScriptStatusLabel.setStyleSheet("color: #4CAF50;")
-                self.AutoScriptPreviewButton.setEnabled(True)
             else:
                 self.AutoScriptStatusLabel.setText("未设置")
                 self.AutoScriptStatusLabel.setStyleSheet("color: #969696;")
-                self.AutoScriptPreviewButton.setEnabled(False)
-        dlg.deleteLater()
-
-    @Slot()
-    def onPreviewAutoScript(self):
-        if not self.__auto_script:
-            return
-        from gui.ALAutoScriptPrevDialog import ALAutoScriptPreviewDialog
-        dlg = ALAutoScriptPreviewDialog(self, self.__auto_script)
-        dlg.exec()
         dlg.deleteLater()
 
     @Slot()
@@ -323,5 +316,3 @@ class ALTimerTaskAddDialog(QDialog, Ui_ALTimerTaskAddDialog):
         QDesktopServices.openUrl(
             QUrl("https://www.autolibrary.kenanzhu.com/manuals/autoscript")
         )
-
-

src/gui/ALTimerTaskHistoryDialog.py

@@ -28,15 +28,14 @@ class ALTimerTaskHistoryDialog(QDialog):
     ):
 
         super().__init__(parent)
-
         self.__task_data = task_data
         self.__history = task_data.get("repeat_history", [])
 
-        self.modifyUi()
+        self.setupUi()
         self.connectSignals()
 
 
-    def modifyUi(
+    def setupUi(
         self
     ):
 

src/gui/ALTimerTaskManageWidget.py

@@ -26,7 +26,9 @@ from PySide6.QtGui import (
 )
 
 import managers.config.ConfigManager as ConfigManager
+
 from utils.TimerUtils import TimerUtils
+from interfaces.ConfigProvider import ConfigProvider, CfgKey
 
 from gui.resources.ui.Ui_ALTimerTaskManageWidget import Ui_ALTimerTaskManageWidget
 from gui.ALTimerTaskAddDialog import ALTimerTaskAddDialog, ALTimerTaskStatus
@@ -190,7 +192,7 @@ class ALTimerTaskManageWidget(QWidget, Ui_ALTimerTaskManageWidget):
     ):
 
         super().__init__(parent)
-        self.__cfg_mgr = ConfigManager.instance()
+        self.__cfg_mgr: ConfigProvider = ConfigManager.instance()
         self.__timer_tasks = []
         self.__check_timer = None
         self.__sort_policy = self.SortPolicy.BY_EXECUTE_TIME
@@ -244,7 +246,7 @@ class ALTimerTaskManageWidget(QWidget, Ui_ALTimerTaskManageWidget):
     ) -> list:
 
         try:
-            timer_tasks = self.__cfg_mgr.get(ConfigManager.ConfigType.TIMERTASK)
+            timer_tasks = self.__cfg_mgr.get(CfgKey.TIMERTASK.ROOT)
             if timer_tasks and "timer_tasks" in timer_tasks:
                 for task in timer_tasks["timer_tasks"]:
                     task["added_time"] = datetime.strptime(task["added_time"], "%Y-%m-%d %H:%M:%S")
@@ -277,7 +279,7 @@ class ALTimerTaskManageWidget(QWidget, Ui_ALTimerTaskManageWidget):
                 if "repeat_history" in task:
                     for item in task["repeat_history"]:
                         item["result"] = item["result"].value
-            self.__cfg_mgr.set(ConfigManager.ConfigType.TIMERTASK, "", { "timer_tasks": timer_tasks })
+            self.__cfg_mgr.set(CfgKey.TIMERTASK.ROOT, { "timer_tasks": timer_tasks })
             return True
         except Exception as e:
             QMessageBox.warning(

src/interfaces/ConfigProvider.py

@@ -0,0 +1,117 @@
+# -*- coding: utf-8 -*-
+"""
+Copyright (c) 2026 KenanZhu.
+All rights reserved.
+
+This software is provided "as is", without any warranty of any kind.
+You may use, modify, and distribute this file under the terms of the MIT License.
+See the LICENSE file for details.
+"""
+from dataclasses import dataclass
+from enum import Enum
+from typing import Any, Optional, Protocol
+
+
+class ConfigType(Enum):
+    """
+        Config type enum. Values represent the default filename.
+    """
+    GLOBAL = "autolibrary.json"
+    BULLETIN = "bulletin.json"
+    TIMERTASK = "timer_task.json"
+
+
+@dataclass(frozen=True)
+class ConfigPath:
+    """
+        A typed configuration path that carries both the config file
+        and the dot-separated key in a single object.
+
+        Consumers pass this directly to ConfigProvider.get/set,
+        eliminating the need to import ConfigType separately.
+    """
+    config_type: ConfigType
+    key: str = ""
+
+
+class CfgKey:
+    """
+        Type-safe hierarchical configuration key constants.
+
+        Each leaf is a ConfigPath that can be passed directly to
+        ``ConfigProvider.get()`` or ``ConfigProvider.set()``.
+
+        Usage::
+
+            CfgKey.GLOBAL.AUTOMATION.RUN_PATH.PATHS
+            # -> ConfigPath(ConfigType.GLOBAL, "automation.run_path.paths")
+
+            config.get(CfgKey.GLOBAL.AUTOMATION.RUN_PATH.PATHS, [])
+            config.set(CfgKey.GLOBAL.AUTOMATION.RUN_PATH.PATHS, value)
+    """
+
+    class GLOBAL:
+        class AUTOMATION:
+            ROOT = ConfigPath(ConfigType.GLOBAL, "automation")
+
+            class RUN_PATH:
+                ROOT = ConfigPath(ConfigType.GLOBAL, "automation.run_path")
+                CURRENT = ConfigPath(ConfigType.GLOBAL, "automation.run_path.current")
+                PATHS = ConfigPath(ConfigType.GLOBAL, "automation.run_path.paths")
+
+            class USER_PATH:
+                ROOT = ConfigPath(ConfigType.GLOBAL, "automation.user_path")
+                CURRENT = ConfigPath(ConfigType.GLOBAL, "automation.user_path.current")
+                PATHS = ConfigPath(ConfigType.GLOBAL, "automation.user_path.paths")
+
+    class TIMERTASK:
+        ROOT = ConfigPath(ConfigType.TIMERTASK, "")
+        TIMER_TASKS = ConfigPath(ConfigType.TIMERTASK, "timer_tasks")
+
+    class BULLETIN:
+        ROOT = ConfigPath(ConfigType.BULLETIN, "")
+        BULLETIN = ConfigPath(ConfigType.BULLETIN, "bulletin")
+        LAST_SYNC_TIME = ConfigPath(ConfigType.BULLETIN, "last_sync_time")
+
+
+class ConfigProvider(Protocol):
+    """
+        Abstract interface for configuration storage access.
+
+        Concrete implementations (e.g. ConfigManager) conform to
+        this protocol structurally rather than through explicit
+        inheritance.
+    """
+
+    def get(
+        self,
+        key: ConfigPath,
+        default: Optional[Any] = None
+    ) -> Any:
+        """
+            Retrieve a configuration value.
+
+            Args:
+                key: A ConfigPath object specifying which config file
+                     and key to read from.
+                default: Fallback value if the key is not found.
+
+            Returns:
+                The configuration value at the given key path.
+        """
+        ...
+
+    def set(
+        self,
+        key: ConfigPath,
+        value: Any = None
+    ) -> None:
+        """
+            Set a configuration value and persist to disk.
+
+            Args:
+                key: A ConfigPath object specifying which config file
+                     and key to write to.
+                value: The value to store.
+        """
+        ...

src/interfaces/__init__.py

@@ -0,0 +1,11 @@
+"""
+    Interfaces module for the AutoLibrary project.
+
+    Defines abstract interfaces (Protocols) and shared type definitions
+    used across layers to decouple consumers from concrete implementations.
+
+    Key components:
+    - ConfigProvider: Abstract interface for configuration access.
+    - ConfigType: Enumeration of configuration file types.
+    - ConfigKey: Type-safe hierarchical key constants for config lookups.
+"""

src/managers/config/ConfigManager.py

@@ -10,26 +10,17 @@ See the LICENSE file for details.
 import os
 import threading
 
-from enum import Enum
 from typing import Any, Optional
 
 from utils.JSONReader import JSONReader
 from utils.JSONWriter import JSONWriter
+from interfaces.ConfigProvider import ConfigType, ConfigPath
 
 
 # This config manager class only responsible for global and other
 # unconfigurable config files.
 
 
-class ConfigType(Enum):
-    """
-        Config type class. Values represent the default filename.
-    """
-    GLOBAL = "autolibrary.json" # Global config file.
-    BULLETIN = "bulletin.json" # Bulletin board config file.
-    TIMERTASK = "timer_task.json" # Timer task config file.
-
-
 class ConfigTemplate:
     """
         Config template class.
@@ -120,16 +111,15 @@ class ConfigManager:
 
     def get(
         self,
-        config_type: ConfigType,
+        key: ConfigPath,
-        key: str = "",
         default: Optional[Any] = None
     ) -> Any:
 
         with self.__config_lock:
-            config_data = self.__config_data[config_type.value]
+            config_data = self.__config_data[key.config_type.value]
-            if key == "":
+            if key.key == "":
                 return config_data
-            keys = key.split('.')
+            keys = key.key.split('.')
             for k in keys[:-1]:
                 config_data = config_data.get(k, None)
                 if config_data is None:
@@ -139,24 +129,23 @@ class ConfigManager:
 
     def set(
         self,
-        config_type: ConfigType,
+        key: ConfigPath,
-        key: str = "",
         value: Any = None
     ):
 
         with self.__config_lock:
-            root_data = self.__config_data[config_type.value]
+            root_data = self.__config_data[key.config_type.value]
-            if key == "":
+            if key.key == "":
-                self.__config_data[config_type.value] = value
+                self.__config_data[key.config_type.value] = value
             else:
-                keys = key.split('.')
+                keys = key.key.split('.')
                 config_data = root_data
                 for k in keys[:-1]:
                     if k not in config_data:
                         config_data[k] = {}
                     config_data = config_data[k]
                 config_data[keys[-1]] = value
-        self.save(config_type)
+        self.save(key.config_type)
 
 
     def save(

src/managers/config/ConfigUtils.py

@@ -11,6 +11,8 @@ import os
 
 import managers.config.ConfigManager as ConfigManager
 
+from interfaces.ConfigProvider import CfgKey
+
 class ConfigUtils:
     """
         Config utilities class.
@@ -29,7 +31,7 @@ class ConfigUtils:
         cfg_mgr = ConfigManager.instance() # config manager instance
 
         config_paths = {"run": "", "user": ""}
-        auto_config = cfg_mgr.get(ConfigManager.ConfigType.GLOBAL, "automation", {})
+        auto_config = cfg_mgr.get(CfgKey.GLOBAL.AUTOMATION.ROOT, {})
         for cfg_type in ["run", "user"]:
                 paths = auto_config.get(f"{cfg_type}_path", {}).get("paths", [])
                 index = auto_config.get(f"{cfg_type}_path", {}).get("current", 0)
@@ -42,5 +44,5 @@ class ConfigUtils:
                 config_paths[cfg_type] = paths[index]
                 data = {"current": index, "paths": paths}
                 auto_config[f"{cfg_type}_path"] = data
-        cfg_mgr.set(ConfigManager.ConfigType.GLOBAL, "automation", auto_config)
+        cfg_mgr.set(CfgKey.GLOBAL.AUTOMATION.ROOT, auto_config)
         return config_paths

src/utils/AutoScriptEngine.py

@@ -1,386 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-Copyright (c) 2026 KenanZhu.
-All rights reserved.
-
-This software is provided "as is", without any warranty of any kind.
-You may use, modify, and distribute this file under the terms of the MIT License.
-See the LICENSE file for details.
-"""
-import re
-from datetime import datetime, timedelta
-
-
-class AutoScriptEngine:
-    """
-        AutoScript script engine.
-
-        Parses and executes AutoScript — a lightweight scripting DSL
-        used in repeatable timer tasks to preprocess user reservation
-        data before automation runs.
-
-        Supports IF/ELSE IF/ELSE/END IF control flow, SET assignments,
-        .ADD./.SUB. operations on Date/Time fields, and rich comparison
-        operators (.EQ. .NEQ. .BGT. .BLT. .BGE. .BLE.).
-
-        Examples:
-            >>> engine = AutoScriptEngine
-            >>> user = {
-            ...     "username": "test",
-            ...     "enabled": True,
-            ...     "reserve_info": {"date": "2026-05-07"}
-            ... }
-            >>> engine.execute(
-            ...     'IF(CURRENT_TIME .BGT. TIME(19:00))\\n'
-            ...     '    RESERVE_DATE .ADD. 1\\n'
-            ...     'END IF',
-            ...     user
-            ... )
-    """
-    COMPARE_OPS = { # compare operators
-        ".EQ." : lambda a, b: a == b,
-        ".NEQ.": lambda a, b: a != b,
-        ".BGT.": lambda a, b: a > b,
-        ".BLT.": lambda a, b: a < b,
-        ".BGE.": lambda a, b: a >= b,
-        ".BLE.": lambda a, b: a <= b,
-    }
-    VARIABLE_META = { # variable metadata
-        "预约开始时间": ("RESERVE_BEGIN_TIME", "Time"),
-        "预约结束时间": ("RESERVE_END_TIME", "Time"),
-        "预约日期": ("RESERVE_DATE", "Date"),
-        "用户名":   ("USERNAME", "String"),
-        "用户启用": ("USER_ENABLE", "Boolean"),
-        "当前时间": ("CURRENT_TIME", "Time"),
-        "当前日期": ("CURRENT_DATE", "Date"),
-    }
-    _FIELD_TYPE_MAP = {meta[0]: meta[1] for meta in VARIABLE_META.values()}
-
-    @staticmethod
-    def execute(
-        script_text: str,
-        user_data: dict
-    ):
-        """
-            Execute an AutoScript against the given user data.
-
-            The script is parsed line-by-line. All modifications are
-            applied directly to ``user_data`` in-place.
-
-            Args:
-                script_text (str): Raw AutoScript source code.
-                user_data (dict): User data dictionary to read from and
-                    write to. Must conform to the standard user profile
-                    structure (username, enabled, reserve_info, etc.).
-
-            Raises:
-                ValueError: On any syntax or type error encountered
-                    during parsing or execution.
-        """
-
-        if not script_text or not script_text.strip():
-            return
-        lines = [l.strip() for l in script_text.split("\n") if l.strip()]
-        if not lines:
-            return
-        if_stack = []
-
-        for line in lines:
-            upper_line = line.upper().strip()
-            if upper_line.startswith("IF("):
-                cond_end = _findConditionEnd(upper_line)
-                if cond_end < 0:
-                    raise ValueError("AutoScript 语法错误: IF 缺少右括号")
-                condition_str = line[3:cond_end].strip()
-                matched = AutoScriptEngine._evaluateCondition(
-                    condition_str, user_data
-                )
-                if_stack.append([matched, matched])
-            elif upper_line.startswith("ELSE IF("):
-                if not if_stack:
-                    raise ValueError("AutoScript 语法错误: ELSE IF 前缺少 IF")
-                cond_end = _findConditionEnd(upper_line)
-                if cond_end < 0:
-                    raise ValueError("AutoScript 语法错误: ELSE IF 缺少右括号")
-                condition_str = line[8:cond_end].strip()
-                _, has_matched = if_stack[-1]
-                if not has_matched:
-                    matched = AutoScriptEngine._evaluateCondition(
-                        condition_str, user_data
-                    )
-                    if_stack[-1] = [matched, matched]
-                else:
-                    if_stack[-1][0] = False
-            elif upper_line == "ELSE":
-                if not if_stack:
-                    raise ValueError("AutoScript 语法错误: ELSE 前缺少 IF")
-                _, has_matched = if_stack[-1]
-                if not has_matched:
-                    if_stack[-1] = [True, True]
-                else:
-                    if_stack[-1][0] = False
-            elif upper_line in ("ENDIF", "END IF"):
-                if not if_stack:
-                    raise ValueError("AutoScript 语法错误: ENDIF/END IF 前缺少 IF")
-                if_stack.pop()
-            elif upper_line.startswith("SET "):
-                should_execute = (
-                    all(ctx[0] for ctx in if_stack) if if_stack else True
-                )
-                if should_execute:
-                    AutoScriptEngine._executeSet(line, user_data)
-            elif upper_line == "PASS":
-                continue
-            else:
-                should_execute = (
-                    all(ctx[0] for ctx in if_stack) if if_stack else True
-                )
-                if should_execute:
-                    AutoScriptEngine._executeOperation(line, user_data)
-        if if_stack:
-            raise ValueError("AutoScript 语法错误: IF 与 ENDIF/END IF 不匹配")
-
-    @staticmethod
-    def _resolveField(
-        field_name: str,
-        user_data: dict
-    ):
-
-        upper_name = field_name.upper().strip()
-        if upper_name == "CURRENT_DATE":
-            return datetime.now().strftime("%Y-%m-%d")
-        elif upper_name == "CURRENT_TIME":
-            return datetime.now().strftime("%H:%M")
-        elif upper_name == "USERNAME":
-            return user_data.get("username", "")
-        elif upper_name == "USER_ENABLE":
-            return user_data.get("enabled", False)
-        elif upper_name == "RESERVE_DATE":
-            return user_data.get("reserve_info", {}).get("date", "")
-        elif upper_name == "RESERVE_BEGIN_TIME":
-            return (
-                user_data
-                .get("reserve_info", {})
-                .get("begin_time", {})
-                .get("time", "")
-            )
-        elif upper_name == "RESERVE_END_TIME":
-            return (
-                user_data
-                .get("reserve_info", {})
-                .get("end_time", {})
-                .get("time", "")
-            )
-        return ""
-
-    @staticmethod
-    def _resolveValue(
-        value_str: str,
-        user_data: dict
-    ):
-
-        s = value_str.strip()
-        time_match = re.match(r"^TIME\((\d{1,2}):(\d{2})\)$", s, re.IGNORECASE)
-        if time_match:
-            h, m = time_match.group(1), time_match.group(2)
-            return f"{int(h):02d}:{int(m):02d}"
-        date_match = re.match(r"^DATE\((\d{4})-(\d{2})-(\d{2})\)$", s, re.IGNORECASE)
-        if date_match:
-            y, mo, d = date_match.group(1), date_match.group(2), date_match.group(3)
-            return f"{int(y):04d}-{int(mo):02d}-{int(d):02d}"
-        if s.upper() == ".TRUE.":
-            return True
-        if s.upper() == ".FALSE.":
-            return False
-        if s.startswith("'") and s.endswith("'"):
-            inner = s[1:-1].replace("''", "'")
-            return inner
-        if s.startswith('"') and s.endswith('"'):
-            return s[1:-1]
-        relDate = re.match(r"^CURRENT_DATE\s*\+\s*(\d+)$", s, re.IGNORECASE)
-        if relDate:
-            days = int(relDate.group(1))
-            return (datetime.now() + timedelta(days=days)).strftime("%Y-%m-%d")
-        relTime = re.match(r"^CURRENT_TIME\s*\+\s*(\d+)$", s, re.IGNORECASE)
-        if relTime:
-            hours = int(relTime.group(1))
-            return (datetime.now() + timedelta(hours=hours)).strftime("%H:%M")
-        try:
-            return int(s)
-        except ValueError:
-            pass
-        try:
-            return float(s)
-        except ValueError:
-            pass
-        resolved = AutoScriptEngine._resolveField(s, user_data)
-        return resolved
-
-    @staticmethod
-    def _setField(
-        field_name: str,
-        value: str,
-        user_data: dict
-    ):
-        upper_name = field_name.upper().strip()
-        if upper_name == "RESERVE_DATE":
-            user_data.setdefault("reserve_info", {})["date"] = value
-        elif upper_name == "RESERVE_BEGIN_TIME":
-            ri = user_data.setdefault("reserve_info", {})
-            ri.setdefault("begin_time", {})["time"] = value
-        elif upper_name == "RESERVE_END_TIME":
-            ri = user_data.setdefault("reserve_info", {})
-            ri.setdefault("end_time", {})["time"] = value
-        elif upper_name == "USERNAME":
-            user_data["username"] = value
-        elif upper_name == "USER_ENABLE":
-            if isinstance(value, bool):
-                user_data["enabled"] = value
-            else:
-                user_data["enabled"] = (str(value).upper() == "TRUE")
-
-    @staticmethod
-    def _evaluateCondition(
-        condition_str: str,
-        user_data: dict
-    ) -> bool:
-
-        for op, cmp_func in AutoScriptEngine.COMPARE_OPS.items():
-            if op not in condition_str.upper():
-                continue
-            idx = condition_str.upper().find(op)
-            parts = [condition_str[:idx], condition_str[idx + len(op):]]
-            if len(parts) != 2:
-                continue
-            field_name = parts[0].strip()
-            value_str = parts[1].strip()
-            left_val = AutoScriptEngine._resolveField(field_name, user_data)
-            right_val = AutoScriptEngine._resolveValue(value_str, user_data)
-            try:
-                return cmp_func(left_val, right_val)
-            except TypeError:
-                raise ValueError(
-                    f"AutoScript 语法错误: 无法比较 "
-                    f"'{field_name}' ({type(left_val).__name__}) "
-                    f"与 '{value_str}' ({type(right_val).__name__})"
-                )
-        return False
-
-    @staticmethod
-    def _executeSet(
-        line: str,
-        user_data: dict
-    ):
-        rest = line[3:].strip()
-        eq_idx = rest.find("=")
-        if eq_idx < 0:
-            return
-        field_name = rest[:eq_idx].strip()
-        value_str = rest[eq_idx + 1:].strip()
-        if not field_name:
-            return
-        resolved = AutoScriptEngine._resolveValue(value_str, user_data)
-        AutoScriptEngine._setField(field_name, resolved, user_data)
-
-    @staticmethod
-    def _executeOperation(
-        line: str,
-        user_data: dict
-    ):
-
-        parts = line.split()
-        if len(parts) < 3:
-            return
-        field_name = parts[0].upper().strip()
-        op = parts[1].upper().strip()
-        raw_value = parts[2].strip()
-        field_type = AutoScriptEngine._FIELD_TYPE_MAP.get(field_name)
-        if not field_type:
-            raise ValueError(
-                f"AutoScript 语法错误: 未知字段 '{field_name}'"
-            )
-        try:
-            num_value = float(raw_value) if "." in raw_value else int(raw_value)
-        except (ValueError, TypeError):
-            raise ValueError(
-                f"AutoScript 语法错误: 无效操作数 '{raw_value}'"
-            )
-        if field_type == "Date":
-            date_str = AutoScriptEngine._resolveField(field_name, user_data)
-            if not date_str:
-                return
-            try:
-                date_obj = datetime.strptime(date_str, "%Y-%m-%d")
-            except (ValueError, TypeError):
-                return
-            if op == ".ADD.":
-                date_obj += timedelta(days=num_value)
-            elif op == ".SUB.":
-                date_obj -= timedelta(days=num_value)
-            else:
-                raise ValueError(
-                    f"AutoScript 语法错误: Date 类型不支持操作 '{op}'"
-                )
-            AutoScriptEngine._setField(
-                field_name, date_obj.strftime("%Y-%m-%d"), user_data
-            )
-        elif field_type == "Time":
-            time_str = AutoScriptEngine._resolveField(field_name, user_data)
-            if not time_str:
-                return
-            try:
-                time_obj = datetime.strptime(time_str, "%H:%M")
-            except (ValueError, TypeError):
-                return
-            if op == ".ADD.":
-                time_obj += timedelta(hours=num_value)
-            elif op == ".SUB.":
-                time_obj -= timedelta(hours=num_value)
-            else:
-                raise ValueError(
-                    f"AutoScript 语法错误: Time 类型不支持操作 '{op}'"
-                )
-            AutoScriptEngine._setField(
-                field_name, time_obj.strftime("%H:%M"), user_data
-            )
-        elif field_type in ("String", "Boolean"):
-            raise ValueError(
-                f"AutoScript 语法错误: '{field_type}' 类型字段不支持操作运算"
-            )
-        else:
-            raise ValueError(
-                f"AutoScript 语法错误: 未知字段类型 '{field_type}'"
-            )
-
-
-def _findConditionEnd(
-    upper_line: str
-) -> int:
-    """
-        Find the index of the closing parenthesis that matches the
-        opening parenthesis in a condition expression, handling nested
-        parentheses and optional ``THEN`` keyword.
-
-        Args:
-            upper_line (str): The uppercased line text containing the
-                condition, e.g. ``"IF(A .BGT. B) THEN"``.
-
-        Returns:
-            int: Index of the matching ``)``, or ``-1`` if no match
-            is found.
-    """
-
-    line = upper_line.rstrip()
-    if line.endswith(" THEN"):
-        line = line[:-5].rstrip()
-    paren_depth = 0
-    start_found = False
-    for i, ch in enumerate(line):
-        if ch == "(":
-            paren_depth += 1
-            start_found = True
-        elif ch == ")":
-            paren_depth -= 1
-            if start_found and paren_depth == 0:
-                return i
-    return -1

src/utils/__init__.py

@@ -5,6 +5,4 @@
     - TimerUtils: Timer utils class for the AutoLibrary project.
     - JSONReader: JSON reader class for the AutoLibrary project.
     - JSONWriter: JSON writer class for the AutoLibrary project.
-    - ConfigUtils: Config utils class for the AutoLibrary project.
-    - AutoScriptEngine: AutoScript script engine class for the AutoLibrary project.
 """