"""Schedule Task tab — Kanban board for scheduled/automated tasks. Columns: Backlog / Scheduled / Running / Waiting Input / Done / Failed / Paused. Cards drag between columns (dropping = changing status), double-click edits, right-click offers Run now / Edit / Duplicate / Pause / Delete / View logs / Create-next-from-output. Header has search, a type filter, Add Task and AI Create Task (preview first — nothing is created until confirmed). """ from __future__ import annotations from ..presentation.scheduling.ai_task_creator_dialog import _AiCreateDialog from ..presentation.scheduling.run_history_dialog import _RunHistoryDialog from ..presentation.scheduling.task_actions import TaskActionsMixin from ..presentation.scheduling.kanban_board_widget import _DropZone, _KanbanColumn import copy from pathlib import Path from typing import Dict, List, Optional from PySide6.QtCore import Qt, Signal from PySide6.QtWidgets import ( QAbstractItemView, QComboBox, QDialog, QDialogButtonBox, QHBoxLayout, QLabel, QLineEdit, QListWidget, QListWidgetItem, QMenu, QMessageBox, QPlainTextEdit, QPushButton, QScrollArea, QSizePolicy, QStackedWidget, QTabBar, QTableWidget, QTableWidgetItem, QVBoxLayout, QWidget, ) from ..core import tasks as taskrepo from ..core.projects import list_projects from ..core.tasks import STATUSES, chain_error, duplicate_task, new_task from ..core.worker import AgentWorker from ..i18n import on_language_changed, tr from ..state import AppContext from ..theme import current_palette from .calendar_view import CalendarView from .icons import icon from .osutil import open_path _VIEWS = ("kanban", "calendar") # Priority shown as a plain text tag (no colored-emoji squares). Only the # elevated priorities get a visible marker; low/medium stay unmarked as before. _PRIORITY_ICONS = {"low": "", "medium": "", "high": "· high", "critical": "· critical"} class ScheduleTaskTab(TaskActionsMixin, QWidget): status_message = Signal(str) def __init__(self, ctx: AppContext, scheduler=None): super().__init__() self.ctx = ctx self.scheduler = scheduler # TaskScheduler (may be None in tests) self._ai_worker: Optional[AgentWorker] = None self._tasks_dir: Optional[Path] = None # None → default repo dir root = QVBoxLayout(self) # ---- header ---------------------------------------------------- header = QHBoxLayout() self._title = QLabel() self._title.setStyleSheet("font-weight:700; font-size:15px;") self.counts_lbl = QLabel("") self.counts_lbl.setObjectName("hint") # A one-line summary of every lane's count. Left to size itself it # reported a sizeHint wide enough to set the MINIMUM width of the whole # screen — 1285px at 150% scaling, which then became the window's # minimum and stopped the app fitting a 1280px laptop. It is a summary, # and the same numbers are on each lane header, so it gives way first. self.counts_lbl.setSizePolicy(QSizePolicy.Ignored, QSizePolicy.Preferred) self.counts_lbl.setMinimumWidth(0) self.add_btn = QPushButton() self.add_btn.setIcon(icon("plus")) self.add_btn.setObjectName("primary") self.add_btn.clicked.connect(self._add_task) self.ai_btn = QPushButton() self.ai_btn.setIcon(icon("sparkle")) self.ai_btn.clicked.connect(self._ai_create) # Two views of the same tasks, so they read as a pair of tabs rather # than a drop-list you have to open to discover the Calendar exists. self.view_tabs = QTabBar() self.view_tabs.setObjectName("viewTabs") self.view_tabs.setDrawBase(False) self.view_tabs.setExpanding(False) for _v in _VIEWS: self.view_tabs.addTab("") self.view_tabs.currentChanged.connect(self._on_view_changed) header.addWidget(self._title) header.addWidget(self.counts_lbl, 1) header.addWidget(self.view_tabs) header.addWidget(self.add_btn) header.addWidget(self.ai_btn) root.addLayout(header) # ---- board / calendar (two views of the SAME tasks) ----------------- self._view_stack = QStackedWidget() scroll = QScrollArea() scroll.setWidgetResizable(True) board = QWidget() scroll.setWidget(board) cols = QHBoxLayout(board) # Gutters wide enough to read as a break between lanes without eating # too much of the seven-way split — they still share the board equally # (see _fit_lanes below), so a wider gutter narrows every lane by the # same share automatically; nothing else to compute here. cols.setSpacing(2) self.columns: Dict[str, _KanbanColumn] = {} self.column_headers: Dict[str, QLabel] = {} for status in STATUSES: box = QVBoxLayout() # The per-lane holder's own margins were the style's default # (~9px a side) on top of the inter-column gap — with seven lanes # that outweighs the gap itself. Zero it out and let the lane's # header/list fill the width _fit_lanes() hands them. box.setContentsMargins(0, 0, 0, 0) box.setSpacing(2) head = QLabel() head.setStyleSheet("font-weight:600;") col = _KanbanColumn(status) col.setObjectName("kanbanLane") col.task_dropped.connect(self._on_task_dropped) col.itemDoubleClicked.connect(self._on_double_click) col.setContextMenuPolicy(Qt.CustomContextMenu) col.customContextMenuRequested.connect( lambda pos, c=col: self._context_menu(c, pos)) box.addWidget(head) box.addWidget(col, 1) holder = QWidget() holder.setLayout(box) cols.addWidget(holder) self.columns[status] = col self.column_headers[status] = head self._board_scroll = scroll self._board_gap = cols.spacing() scroll.viewport().installEventFilter(self) self._view_stack.addWidget(scroll) self.calendar = CalendarView() self.calendar.edit_task.connect(self._edit_task) self.calendar.add_task_on_date.connect(self._add_task_on_date) self._view_stack.addWidget(self.calendar) root.addWidget(self._view_stack, 1) if self.scheduler is not None: self.scheduler.tasks_changed.connect(self.refresh) self.scheduler.task_started.connect(lambda _tid: self.refresh()) self.scheduler.task_finished.connect(lambda _tid, _ok: self.refresh()) # Belt-and-braces: also re-read the board every 10s so a card's lane # ALWAYS reflects reality (Scheduled → Running → Done) even if some # change slipped past the signals (e.g. task files edited externally). from PySide6.QtCore import QTimer self._refresh_timer = QTimer(self) self._refresh_timer.setInterval(10_000) self._refresh_timer.timeout.connect(self.refresh) self._refresh_timer.start() self.refresh() on_language_changed(self._retranslate) # ---- i18n ------------------------------------------------------------ def _retranslate(self) -> None: self._title.setText(tr("schedtask.title")) self.add_btn.setText(tr("schedtask.add_btn")) self.add_btn.setToolTip(tr("schedtask.add_tooltip")) self.ai_btn.setText(tr("schedtask.ai_btn")) self.ai_btn.setToolTip(tr("schedtask.ai_tooltip")) for i, v in enumerate(_VIEWS): self.view_tabs.setTabText(i, tr(f"schedtask.view.{v}")) for status, col in self.columns.items(): col.setToolTip(tr(f"schedtask.col_tip.{status}")) self.refresh() # ---- Kanban / Calendar view switch -------------------------------- def _on_view_changed(self) -> None: self._view_stack.setCurrentIndex(self.view_tabs.currentIndex()) # ---- lane widths ------------------------------------------------------ # # The seven lanes share the board equally — that is the layout's stretch # doing the work, so the split is a proportion of whatever width there is, # on any monitor. The only pixel question left is how narrow a lane may get # before scrolling sideways beats squeezing, and that is a question about # TEXT: roughly eight characters of a task title plus its padding. Reading # it off the font keeps it right at 125%/150% scaling and at a user's own # font size, where a constant would not be. _LANE_FLOOR_CH = 8 def eventFilter(self, obj, event): # noqa: N802 from PySide6.QtCore import QEvent if obj is self._board_scroll.viewport() and event.type() == QEvent.Resize: self._fit_lanes() return super().eventFilter(obj, event) def _fit_lanes(self) -> None: floor = self.fontMetrics().averageCharWidth() * self._LANE_FLOOR_CH + 24 for col in self.columns.values(): if col.minimumWidth() != floor: col.setMinimumWidth(floor) # ---- board rendering --------------------------------------------------- def _card_text(self, t: dict) -> str: prio = _PRIORITY_ICONS.get(t.get("priority", "medium"), "") ai = "[AI] " if t.get("is_ai_generated") else "" sched = t.get("schedule", {}) when = sched.get("run_at") if sched.get("enabled") else None when_line = when or tr("schedtask.no_schedule") chain = "" if t.get("dependency", {}).get("next_task_id") or t.get("dependency", {}).get("previous_task_id"): chain = " (linked)" last = t.get("logs", {}).get("last_status") last_line = {"success": tr("schedtask.last_success"), "failed": tr("schedtask.last_failed")}.get(last, tr("schedtask.last_never")) # Card shows ONLY the task's own title (plus the [AI] marker and chain # note) — no "[Cowork]"/"[Code]" task-type tag cluttering it. return (f"{ai}{t.get('title', '')}{chain}\n" f"{when_line} {prio}\n{last_line}") def refresh(self) -> None: all_tasks = taskrepo.list_tasks(self._tasks_dir) counts = {s: 0 for s in STATUSES} for col in self.columns.values(): col.clear() for t in all_tasks: status = t.get("status", "backlog") if status not in self.columns: continue counts[status] += 1 item = QListWidgetItem(self._card_text(t)) item.setData(Qt.UserRole, t["task_id"]) self.columns[status].addItem(item) pal = current_palette() for status, col in self.columns.items(): self.column_headers[status].setText( f"{tr(f'schedtask.status.{status}')} ({counts[status]})") # Dropping a card into Running STARTS the task for real, so that # lane is outlined while it holds anything — the one column here # with a side effect should not look like the other six. if status == "running" and counts[status]: col.setStyleSheet( f"border: 1px solid {pal.warning}; border-radius: {pal.radius}px;") self.column_headers[status].setStyleSheet( f"font-weight:600; color: {pal.warning};") else: col.setStyleSheet("") self.column_headers[status].setStyleSheet("font-weight:600;") if col.count() == 0: empty = QListWidgetItem(tr("schedtask.no_tasks")) empty.setFlags(Qt.NoItemFlags) col.addItem(empty) summary = " ".join( f"{tr(f'schedtask.status.{s}')}: {counts[s]}" for s in STATUSES if counts[s]) self.counts_lbl.setText(summary) self.counts_lbl.setToolTip(summary) # full text stays reachable if clipped self.calendar.set_tasks(all_tasks) # ---- actions -------------------------------------------------------- def _on_task_dropped(self, task_id: str, new_status: str) -> None: """Dropping a card into a lane ACTS on the task, not just relabels it: → Running actually runs it now; → Done marks it completed; → Scheduled puts it on the calendar (opening the editor if no time is set yet).""" task = taskrepo.load_task(task_id, self._tasks_dir) if not task: return if task.get("status") == "running": self.refresh() # can't drag a running task return if new_status == "running": # Dropping into Running = "run it now" (counts as manual approval). self.refresh() self._run_now(task) return if new_status == "done": task["status"] = "done" task["schedule"]["enabled"] = False # done by hand → don't re-fire self._save_and_refresh(task) return task["status"] = new_status if new_status == "scheduled" and not task["schedule"].get("enabled"): if task["schedule"].get("run_at"): task["schedule"]["enabled"] = True else: # No time set yet — a silently-disabled "Scheduled" card would # never run and look broken. Open the editor so the user sets # the schedule right away. self._save_and_refresh(task) self.status_message.emit(tr("schedtask.msg_set_schedule")) self._edit_task(task_id) return self._save_and_refresh(task)