Coverage for vibefpmgui/review_monitor.py: 96%

1"""The *Review* tab: a timeline of everything the AI does (reviews, 

2*Explain with AI*, questions and edits from the box at the bottom), newest 

3at the bottom. Nothing replaces anything: each action adds an entry, older 

4ones fold to a one-line header (click to open), and everything in them 

5stays usable: findings jump to their line or get *Fix with AI…*, a review's 

6markers go back in the editor, edits can still be accepted. The timeline 

7lasts until the app quits (or *Clear*); *New Chat* draws a line: the model 

8forgets what's above it. 

9 

10The panel only shows `Entry` objects and says what the user did; 

11`vibefpmgui.window.ai` and `vibefpmgui.window.ai_chat` run the model and change files. 

12""" 

13 

14from __future__ import annotations 

15 

16import html 

17import re 

18import time 

19from dataclasses import dataclass, field 

20from pathlib import Path 

21from typing import Any 

22 

23from pygments.lexers import get_lexer_by_name 

24from pygments.styles import get_style_by_name 

25from pygments.util import ClassNotFound 

26from qtpy.QtCore import QEvent, Qt, QTimer, Signal 

27from qtpy.QtGui import ( 

28 QColor, 

29 QFont, 

30 QTextBlockFormat, 

31 QTextCharFormat, 

32 QTextCursor, 

33 QTextFormat, 

34) 

35from qtpy.QtWidgets import ( 

36 QApplication, 

37 QButtonGroup, 

38 QCheckBox, 

39 QFrame, 

40 QHBoxLayout, 

41 QLabel, 

42 QLineEdit, 

43 QPushButton, 

44 QScrollArea, 

45 QSizePolicy, 

46 QTextBrowser, 

47 QToolButton, 

48 QVBoxLayout, 

49 QWidget, 

50) 

51 

52from . import ai_edits as ed 

53from . import highlighter as hl 

54from .ai_edits import END_RE as EDIT_END_RE 

55from .ai_edits import START_RE as EDIT_START_RE 

56from .ai_review import Finding 

57from .build_monitor import ( 

58 PALETTES, 

59 ProgressLine, 

60 TitleIcon, 

61 app_is_light, 

62 panel_stylesheet, 

63) 

64from .edit_cards import EditList 

65from .editor import monospace_font 

66from .widgets import StatusLabel 

67 

68FINDING_LINE_RE = re.compile(r"\s*\**\s*LINES?\s*\d", re.IGNORECASE) # (a finding in a chat answer) 

69 

70CATEGORY_COLORS = {"bug": "#e03131", "warning": "#f08c00", "performance": "#0c8599", 

71 "style": "#7048e8", "suggestion": "#1c7ed6"} 

72CATEGORY_ICONS = {"bug": "✕", "warning": "⚠", "performance": "⚡", "style": "✎", "suggestion": "💡"} 

73KINDS = {"review": ("Review", "#7048e8"), "explain": ("Explain", "#0c8599"), "ask": ("Ask", "#1c7ed6"), 

74 "edit": ("Edit", "#2f9e44")} 

75FILTERS = {"all": "All", "review": "Reviews", "explain": "Explanations", "chat": "Chat", 

76 "pending": "Pending edits"} 

77RUNNING, DONE, FAILED = "running", "done", "failed" 

78 

79 

80def _esc(text: str) -> str: 

81 """Text for a label (quotes as they are: it's not an attribute).""" 

82 return html.escape(text, quote=False) 

83 

84 

85@dataclass 

86class Entry: 

87 """One AI action: a review, an explanation, a question (Ask) or a 

88 change (Edit); or a divider (New Chat: the model forgets what's above).""" 

89 kind: str # "review", "explain", "ask", "edit", "divider" 

90 question: str = "" # the question; the problem explained; a review's focus 

91 path: Path | None = None # the file it's about 

92 where: str = "" # shown in the header: "foo.f90", "foo.f90:12" 

93 model: str = "" 

94 answer: str = "" # as the model wrote it (Markdown) 

95 reasoning: str = "" # a thinking model's, before its answer (AI → Think Before Answering) 

96 findings: list[Finding] = field(default_factory=list) 

97 summary: str = "" # a review's 

98 edits: list[ed.Edit] = field(default_factory=list) 

99 status: str = RUNNING 

100 note: str = "" # "4.1 s · model", or what went wrong 

101 started: str = field(default_factory=lambda: time.strftime("%H:%M")) 

102 turn: Any = None # what the model was asked (an ai_context.Turn), for later questions 

103 

104 def pending_edits(self) -> int: 

105 return sum(e.status == ed.PENDING and e.located for e in self.edits) 

106 

107 def markdown(self) -> str: 

108 """The entry as text (Copy).""" 

109 if self.kind == "review": 109 ↛ 110line 109 didn't jump to line 110 because the condition on line 109 was never true

110 lines = [f"**Review of {self.where}** ({self.question})", ""] 

111 lines += [f"- LINE {f.line}{'' if f.end_line == f.line else f'-{f.end_line}'}: {f.category}: " 

112 f"{f.comment}" for f in self.findings] 

113 return "\n".join(lines + ([f"\n**Summary:** {self.summary}"] if self.summary else [])) 

114 if self.kind == "explain": 114 ↛ 115line 114 didn't jump to line 115 because the condition on line 114 was never true

115 return f"**{self.where}:** {self.question}\n\n{self.answer}" 

116 return f"**You:** {self.question}\n\n{self.answer}" 

117 

118 

119def answer_display(answer: str) -> str: 

120 """A chat answer as shown: its "LINE n: …" lines each on their own 

121 (Markdown would run them together), as a list; its edit blocks as a 

122 pointer to their card.""" 

123 shown: list[str] = [] 

124 fenced = in_block = drop_fence = False 

125 n = 0 

126 for line in answer.split("\n"): 

127 fence = line.lstrip().startswith("```") 

128 if in_block: 

129 if EDIT_END_RE.match(line): 

130 in_block = False 

131 shown[-1] = f"*✎ Edit {n}: see its card below.*" 

132 continue 

133 if EDIT_START_RE.match(line): 

134 in_block, n = True, n + 1 

135 if fenced and shown and shown[-1].lstrip().startswith("```"): # (a fence just around it) 

136 shown.pop() 

137 fenced, drop_fence = False, True 

138 shown.append(f"*✎ Writing edit {n}…*") 

139 continue 

140 if drop_fence and fence: # (that fence's end) 

141 drop_fence = False 

142 continue 

143 if line.strip(): 

144 drop_fence = False 

145 if fence: 

146 fenced = not fenced 

147 elif not fenced and FINDING_LINE_RE.match(line): 

148 line = "- " + line.strip() 

149 shown.append(line) 

150 return "\n".join(shown) 

151 

152 

153def style_code(document, family: str, style_name: str | None = None): 

154 """Code in a Markdown document in a fixed-width font (Qt's Markdown asks 

155 only for "monospace", which macOS turns into a serif font, or ignores), 

156 and code blocks labeled with a language (```fortran, ```toml…) 

157 highlighted as the editor would, in its colors (``style_name``: a 

158 Pygments style; by default the one the editor uses).""" 

159 fixed = QTextCharFormat() 

160 fixed.setFontFamilies([family]) 

161 cursor = QTextCursor(document) 

162 block = document.begin() 

163 while block.isValid(): 

164 if block.blockFormat().hasProperty(QTextFormat.BlockCodeFence): 

165 language = str(block.blockFormat().property(QTextFormat.BlockCodeLanguage) or "") 

166 lines = [] 

167 while block.isValid() and block.blockFormat().hasProperty(QTextFormat.BlockCodeFence) \ 

168 and str(block.blockFormat().property(QTextFormat.BlockCodeLanguage) or "") == language: 

169 lines.append(block) 

170 block = block.next() 

171 cursor.setPosition(lines[0].position()) 

172 cursor.setPosition(lines[-1].position() + lines[-1].length() - 1, QTextCursor.KeepAnchor) 

173 cursor.mergeCharFormat(fixed) 

174 _highlight(cursor, lines, language, style_name) 

175 continue 

176 it = block.begin() 

177 while not it.atEnd(): 

178 fragment = it.fragment() 

179 if fragment.charFormat().fontFixedPitch(): 

180 cursor.setPosition(fragment.position()) 

181 cursor.setPosition(fragment.position() + fragment.length(), QTextCursor.KeepAnchor) 

182 cursor.mergeCharFormat(fixed) 

183 it += 1 

184 block = block.next() 

185 

186 

187def _highlight(cursor: QTextCursor, lines: list, language: str, style_name: str | None): 

188 """One code block's lines, colored by the lexer for ``language``.""" 

189 if not language: 

190 return 

191 try: 

192 lexer = hl.keep_positions(get_lexer_by_name(language)) 

193 style = get_style_by_name(style_name or hl.style_name(QApplication.palette())) 

194 except ClassNotFound: 

195 return # (a language Pygments doesn't know: plain) 

196 background = QTextBlockFormat() 

197 background.setBackground(QColor(style.background_color)) 

198 plain = QTextCharFormat() 

199 plain.setForeground(hl.style_text_color(style)) 

200 first = lines[0].position() 

201 cursor.setPosition(first) 

202 cursor.setPosition(lines[-1].position() + lines[-1].length() - 1, QTextCursor.KeepAnchor) 

203 cursor.mergeBlockFormat(background) 

204 cursor.mergeCharFormat(plain) 

205 text = "\n".join(line.text() for line in lines) # (a line break is one position, as between blocks) 

206 for index, ttype, value in lexer.get_tokens_unprocessed(text): 

207 if value and not value.isspace(): 

208 cursor.setPosition(first + index) 

209 cursor.setPosition(first + index + len(value), QTextCursor.KeepAnchor) 

210 cursor.mergeCharFormat(hl.token_format(style, ttype)) 

211 

212 

213class MarkdownView(QTextBrowser): 

214 """Markdown as tall as its text (the timeline scrolls, not this).""" 

215 

216 def __init__(self, parent=None): 

217 super().__init__(parent) 

218 self.setOpenExternalLinks(True) 

219 self.setFrameShape(QFrame.NoFrame) 

220 self.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff) 

221 self.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed) 

222 self.document().documentLayout().documentSizeChanged.connect( 

223 lambda size: self.setFixedHeight(int(size.height()) + 6)) 

224 self._text = None 

225 

226 def set_markdown(self, text: str): 

227 if text != self._text: 

228 self._text = text 

229 self.setMarkdown(text) 

230 style_code(self.document(), monospace_font(editor=True).family()) 

231 

232 def restyle(self): 

233 """Again, in the editor's colors as they are now.""" 

234 text, self._text = self._text, None 

235 if text is not None: 

236 self.set_markdown(text) 

237 

238 

239class WrappedLabel(QLabel): 

240 """A word-wrapped label that remembers its size for its text: Qt asks a 

241 wrapped label its height again on every layout pass, laying out its text 

242 each time, and with the timeline's findings (hundreds of rows) and an 

243 answer streaming in, that kept the window busy.""" 

244 

245 def __init__(self, text: str = ""): 

246 super().__init__(text) 

247 self.setWordWrap(True) 

248 self._heights: dict[int, int] = {} 

249 self._hints: dict[str, object] = {} 

250 

251 def setText(self, text: str): 

252 if text != self.text(): 252 ↛ 254line 252 didn't jump to line 254 because the condition on line 252 was always true

253 self._forget() 

254 super().setText(text) 

255 

256 def _forget(self): 

257 self._heights.clear() 

258 self._hints.clear() 

259 

260 def changeEvent(self, event): 

261 if event.type() in (QEvent.FontChange, QEvent.StyleChange): 

262 self._forget() 

263 super().changeEvent(event) 

264 

265 def heightForWidth(self, width: int) -> int: 

266 height = self._heights.get(width) 

267 if height is None: 

268 height = self._heights[width] = super().heightForWidth(width) 

269 return height 

270 

271 def sizeHint(self): 

272 if "size" not in self._hints: 272 ↛ 274line 272 didn't jump to line 274 because the condition on line 272 was always true

273 self._hints["size"] = super().sizeHint() 

274 return self._hints["size"] 

275 

276 def minimumSizeHint(self): 

277 if "minimum" not in self._hints: 277 ↛ 279line 277 didn't jump to line 279 because the condition on line 277 was always true

278 self._hints["minimum"] = super().minimumSizeHint() 

279 return self._hints["minimum"] 

280 

281 

282class FindingRow(QWidget): 

283 """One finding: its line, category and comment; click to go to the 

284 line; Fix with AI…""" 

285 

286 def __init__(self, view: FindingsView): 

287 super().__init__() 

288 self.finding: Finding | None = None 

289 self.setObjectName("FindingRow") 

290 self.setCursor(Qt.PointingHandCursor) 

291 self.label = WrappedLabel() 

292 self.label.setToolTip("Go to the line") 

293 fix = QToolButton() 

294 fix.setText("Fix with AI…") 

295 fix.setToolTip("Ask the AI for an edit that addresses this finding") 

296 fix.clicked.connect(lambda: self.finding is not None and view.fix.emit(self.finding)) 

297 box = QHBoxLayout(self) 

298 box.setContentsMargins(6, 3, 6, 3) 

299 box.addWidget(self.label, 1) 

300 box.addWidget(fix, 0, Qt.AlignTop) 

301 self._view = view 

302 

303 def mousePressEvent(self, event): 

304 if event.button() == Qt.LeftButton and self.finding is not None: 304 ↛ 306line 304 didn't jump to line 306 because the condition on line 304 was always true

305 self._view.clicked.emit(self.finding) 

306 super().mousePressEvent(event) 

307 

308 

309class FindingsView(QWidget): 

310 """Findings, one row each: click to go to the line; Fix with AI… 

311 

312 The rows are kept and updated in place (only a row whose finding changed 

313 gets new text; new findings add rows at the end): rebuilding every row 

314 for each finding a review streamed in took ever longer, and with a few 

315 dozen findings the window crawled.""" 

316 

317 clicked = Signal(object) 

318 fix = Signal(object) 

319 

320 def __init__(self, parent=None): 

321 super().__init__(parent) 

322 self.layout_ = QVBoxLayout(self) 

323 self.layout_.setContentsMargins(0, 0, 0, 0) 

324 self.layout_.setSpacing(2) 

325 self.rows: list[FindingRow] = [] 

326 

327 def show_findings(self, findings: list[Finding], pal: dict, is_light: bool): 

328 family = monospace_font(editor=True).family() 

329 # Each row stays with its finding (by line and category): a finding 

330 # coming in between others gets a new row there, rather than every 

331 # row below taking the next one's text (and being measured again). 

332 spare: dict[tuple, list[FindingRow]] = {} 

333 for row in self.rows: 

334 spare.setdefault(self._key(row.finding), []).append(row) 

335 rows = [] 

336 for f in sorted(findings, key=lambda f: f.line): 

337 same = spare.get(self._key(f)) 

338 row = same.pop(0) if same else FindingRow(self) 

339 row.finding = f 

340 color = CATEGORY_COLORS.get(f.category, pal["muted"]) 

341 lines = str(f.line) if f.end_line == f.line else f"{f.line}–{f.end_line}" 

342 text = (f"<span style='font-family:\"{family}\"'>{lines}</span>" 

343 f"&nbsp;&nbsp;<b style='color:{color}'>{CATEGORY_ICONS.get(f.category, '')} " 

344 f"{_esc(f.category)}</b>&nbsp;&nbsp;{_esc(f.comment)}") 

345 if row.label.text() != text: # (only what changed is measured again) 

346 row.label.setText(text) 

347 rows.append(row) 

348 for left in spare.values(): 

349 for row in left: 

350 self.layout_.removeWidget(row) 

351 row.deleteLater() 

352 for index, row in enumerate(rows): # (new rows into their places; the others keep theirs) 

353 if self.layout_.indexOf(row) != index: 

354 self.layout_.insertWidget(index, row) 

355 self.rows = rows 

356 self.setVisible(bool(findings)) 

357 

358 @staticmethod 

359 def _key(f: Finding | None) -> tuple: 

360 return (f.line, f.end_line, f.category) if f is not None else () 

361 

362 

363class EntryWidget(QFrame): 

364 """One entry of the timeline: a header (click to fold or open it) and 

365 what it holds.""" 

366 

367 def __init__(self, entry: Entry, monitor: ReviewMonitor): 

368 super().__init__() 

369 self.entry, self.monitor = entry, monitor 

370 self.expanded = True 

371 self.setObjectName("Entry") 

372 self.header = QWidget() 

373 self.header.setCursor(Qt.PointingHandCursor) 

374 self.header.mousePressEvent = lambda event: self.set_expanded(not self.expanded) \ 

375 if event.button() == Qt.LeftButton else None 

376 self.kind = QLabel() 

377 self.title = QLabel() 

378 self.title.setTextFormat(Qt.RichText) 

379 self.title.setSizePolicy(QSizePolicy.Ignored, QSizePolicy.Preferred) 

380 self.when = QLabel() 

381 self.show_button = QToolButton() 

382 self.show_button.setText("Show in Editor") 

383 self.show_button.setToolTip("Mark these findings in the editor again") 

384 self.show_button.clicked.connect(lambda: monitor.show_in_editor_requested.emit(entry)) 

385 self.copy_button = QToolButton() 

386 self.copy_button.setText("Copy") 

387 self.copy_button.setToolTip("Copy this entry (Markdown)") 

388 self.copy_button.clicked.connect(lambda: QApplication.clipboard().setText(entry.markdown())) 

389 self.chevron = QLabel() 

390 top = QHBoxLayout(self.header) 

391 top.setContentsMargins(0, 0, 0, 0) 

392 top.setSpacing(8) 

393 top.addWidget(self.chevron) 

394 top.addWidget(self.kind) 

395 top.addWidget(self.title, 1) 

396 top.addWidget(self.show_button) 

397 top.addWidget(self.copy_button) 

398 top.addWidget(self.when) 

399 

400 self.body = QWidget() 

401 self.question = QLabel() 

402 self.question.setWordWrap(True) 

403 self.question.setTextInteractionFlags(Qt.TextSelectableByMouse) 

404 self.reasoning_button = QToolButton() 

405 self.reasoning_button.setCheckable(True) 

406 self.reasoning_button.setText("Show reasoning") 

407 self.reasoning_button.toggled.connect(self._show_reasoning) 

408 self.reasoning_button.setToolTip("What the model thought before it answered") 

409 self.reasoning = QLabel() 

410 self.reasoning.setWordWrap(True) 

411 self.reasoning.setTextInteractionFlags(Qt.TextSelectableByMouse) 

412 self.reasoning.setTextFormat(Qt.PlainText) 

413 self.reasoning.hide() 

414 self.answer = MarkdownView() 

415 self.findings = FindingsView() 

416 self.findings.clicked.connect(lambda f: monitor.finding_selected.emit(entry, f)) 

417 self.findings.fix.connect(lambda f: monitor.fix_requested.emit(entry, f)) 

418 self.summary = QLabel() 

419 self.summary.setWordWrap(True) 

420 self.summary.setTextInteractionFlags(Qt.TextSelectableByMouse) 

421 self.edit_list = EditList(scrolling=False) 

422 self.edit_list.accept_requested.connect(lambda i: monitor.accept_requested.emit(entry, i)) 

423 self.edit_list.reject_requested.connect(lambda i: monitor.reject_requested.emit(entry, i)) 

424 self.edit_list.accept_all_requested.connect(lambda: monitor.accept_all_requested.emit(entry)) 

425 self.edit_list.reject_all_requested.connect(lambda: monitor.reject_all_requested.emit(entry)) 

426 self.edit_list.edit_clicked.connect(lambda i: monitor.edit_clicked.emit(entry, i)) 

427 self.edit_list.hide() 

428 self.footer = QLabel() 

429 body = QVBoxLayout(self.body) 

430 body.setContentsMargins(22, 4, 0, 0) 

431 body.setSpacing(6) 

432 for widget in (self.question, self.reasoning_button, self.reasoning, self.answer, self.findings, 

433 self.summary, self.edit_list, self.footer): 

434 body.addWidget(widget) 

435 layout = QVBoxLayout(self) 

436 layout.setContentsMargins(10, 8, 10, 8) 

437 layout.setSpacing(4) 

438 layout.addWidget(self.header) 

439 layout.addWidget(self.body) 

440 self.refresh() 

441 

442 def _show_reasoning(self, on: bool): 

443 self.reasoning_button.setText("Hide reasoning" if on else "Show reasoning") 

444 self.reasoning.setText(self.entry.reasoning.strip()) 

445 self.reasoning.setVisible(on) 

446 

447 def set_expanded(self, on: bool): 

448 self.expanded = on 

449 self.refresh() 

450 

451 def refresh(self, file_text: str | None = None): 

452 """Show the entry as it is now (``file_text``: its file's text, for 

453 the edit cards' diffs).""" 

454 e, pal = self.entry, self.monitor.palette_colors 

455 muted = pal["muted"] 

456 label, color = KINDS.get(e.kind, (e.kind, muted)) 

457 self.kind.setText(f"<b style='color:{color}'>{label}</b>") 

458 self.chevron.setText("▾" if self.expanded else "▸") 

459 self.title.setText(self._title(muted)) 

460 self.when.setText(f"<span style='color:{muted}'>{e.started}</span>") 

461 self.show_button.setVisible(bool(e.findings) and e.path is not None) 

462 self.copy_button.setVisible(self.expanded and (bool(e.answer) or bool(e.findings))) 

463 self.body.setVisible(self.expanded) 

464 if not self.expanded: 

465 return 

466 if e.kind == "review": 

467 question = f"<span style='color:{muted}'>{_esc(e.question)}</span>" 

468 if e.status == RUNNING and not e.findings: 

469 question += f"<br><i style='color:{muted}'>Findings appear here as the model writes them.</i>" 

470 elif e.status == DONE and not e.findings: 470 ↛ 471line 470 didn't jump to line 471 because the condition on line 470 was never true

471 question += "<br><i>No specific findings.</i>" 

472 elif e.kind == "explain": 

473 question = f"<b>{_esc(e.question)}</b>" 

474 else: 

475 question = f"<b>You:</b> {_esc(e.question)}" 

476 self.question.setText(question) 

477 self.reasoning_button.setVisible(bool(e.reasoning)) 

478 if e.reasoning and self.reasoning.isVisibleTo(self.body): 478 ↛ 479line 478 didn't jump to line 479 because the condition on line 478 was never true

479 self.reasoning.setText(e.reasoning.strip()) 

480 self.reasoning.setStyleSheet(f"color: {muted};") 

481 if e.kind == "review": 

482 text = "" 

483 elif e.kind == "explain": 

484 text = e.answer 

485 else: 

486 text = answer_display(e.answer) 

487 if e.status == FAILED and not e.answer and e.kind != "review": 

488 text = f"*{e.note}*" 

489 self.answer.setVisible(bool(text)) 

490 self.answer.set_markdown(text) 

491 self.findings.show_findings(e.findings, pal, self.monitor.is_light) 

492 self.summary.setText(f"<b>Summary:</b> {_esc(e.summary)}" if e.summary else "") 

493 self.summary.setVisible(bool(e.summary)) 

494 if e.edits and file_text is not None: 

495 self.edit_list.set_palette(pal, self.monitor.is_light) 

496 self.edit_list.show_edits(e.edits, file_text, e.where, monospace_font(editor=True).family()) 

497 self.edit_list.setVisible(bool(e.edits)) 

498 note = e.note if e.status != RUNNING else "" 

499 if e.status == FAILED and e.kind != "review" and not e.answer: 

500 note = "" # (said above) 

501 self.footer.setText(f"<span style='color:{'#e03131' if e.status == FAILED else muted}'>" 

502 f"{_esc(note)}</span>" if note else "") 

503 self.footer.setVisible(bool(note)) 

504 

505 def _title(self, muted: str) -> str: 

506 e = self.entry 

507 parts = [] 

508 if e.kind in ("ask", "edit", "explain"): 

509 question = e.question if len(e.question) <= 80 else e.question[:77] + "…" 

510 parts.append(f"“{_esc(question)}”") 

511 if e.where: 

512 parts.append(_esc(e.where)) 

513 if e.kind == "review" and e.question: 

514 parts.append(_esc(e.question.lower())) 

515 status = "" 

516 if e.status == RUNNING: 

517 status = "running…" 

518 elif e.status == FAILED: 

519 status = "failed" if "stopped" not in e.note.lower() else "stopped" 

520 elif e.kind == "review" or e.findings: 

521 status = f"{len(e.findings)} finding{'s' * (len(e.findings) != 1)}" 

522 if e.edits: 

523 applied = sum(x.status == ed.APPLIED for x in e.edits) 

524 pending = e.pending_edits() 

525 status = ", ".join(s for s in (status if e.status != DONE else "", 

526 f"{applied} of {len(e.edits)} applied", 

527 f"{pending} pending" if pending else "") if s) 

528 text = " · ".join(parts) 

529 return text + (f" <span style='color:{muted}'>· {status}</span>" if status else "") 

530 

531 

532class Divider(QLabel): 

533 def __init__(self): 

534 super().__init__("— New chat: the AI forgets everything above —") 

535 self.setAlignment(Qt.AlignCenter) 

536 self.entry = Entry("divider", status=DONE) 

537 

538 def refresh(self, _file_text=None): 

539 self.setStyleSheet(f"color: {PALETTES['light' if app_is_light() else 'dark']['muted']};") 

540 

541 

542class ReviewMonitor(QWidget): 

543 """The timeline, the progress of what's running (and Stop), and the box 

544 for questions (Ask) and changes (Edit). It emits what the user does.""" 

545 

546 stop_requested = Signal() 

547 chat_requested = Signal(str, bool, str) # question, send the open file along, "ask" or "edit" 

548 new_chat_requested = Signal() 

549 clear_requested = Signal() 

550 selection_cleared = Signal() 

551 finding_selected = Signal(object, object) # entry, finding 

552 fix_requested = Signal(object, object) # entry, finding 

553 show_in_editor_requested = Signal(object) # entry 

554 accept_requested = Signal(object, int) # entry, edit's index 

555 reject_requested = Signal(object, int) 

556 accept_all_requested = Signal(object) 

557 reject_all_requested = Signal(object) 

558 edit_clicked = Signal(object, int) 

559 

560 def __init__(self, parent=None): 

561 super().__init__(parent) 

562 self.entries: list[Entry] = [] 

563 self.widgets: list[EntryWidget | Divider] = [] 

564 self.current: Entry | None = None # the one running 

565 self.filter = "all" 

566 self.context_note = "" # how full the model's context is ("context ~14k of 32k") 

567 self.is_light = True 

568 self.palette_colors = PALETTES["light"] 

569 self._started = 0.0 

570 self._tokens = 0 

571 self._status = "" 

572 self._follow = True # (keep the newest in view, unless scrolled up) 

573 

574 self.setObjectName("ReviewMonitor") 

575 self.setAttribute(Qt.WA_StyledBackground, True) 

576 self.title_icon = TitleIcon("robot") 

577 self.title = QLabel("AI") 

578 self.subtitle = StatusLabel() 

579 header = QHBoxLayout() 

580 header.setSpacing(6) 

581 header.addWidget(self.title_icon) 

582 header.addWidget(self.title) 

583 header.addSpacing(4) 

584 header.addWidget(self.subtitle) 

585 header.addStretch(1) 

586 self.filter_buttons: dict[str, QPushButton] = {} 

587 group = QButtonGroup(self) 

588 for key, label in FILTERS.items(): 

589 button = QPushButton(label) 

590 button.setCheckable(True) 

591 button.setObjectName("Filter") 

592 button.clicked.connect(lambda _=False, k=key: self.set_filter(k)) 

593 group.addButton(button) 

594 header.addWidget(button) 

595 self.filter_buttons[key] = button 

596 self.filter_buttons["all"].setChecked(True) 

597 self.clear_button = QPushButton("Clear") 

598 self.clear_button.setToolTip("Empty the timeline (the AI forgets it too)") 

599 self.clear_button.clicked.connect(self.clear_requested) 

600 header.addSpacing(6) 

601 header.addWidget(self.clear_button) 

602 

603 self.progress = ProgressLine(self) 

604 self.progress_label = StatusLabel() 

605 self.stop_button = QPushButton("Stop") 

606 self.stop_button.setToolTip("Stop the model") 

607 self.stop_button.clicked.connect(self.stop_requested) 

608 self.stop_button.hide() 

609 progress_row = QHBoxLayout() 

610 progress_row.setSpacing(10) 

611 progress_row.addWidget(self.progress, 1) 

612 progress_row.addWidget(self.progress_label) 

613 progress_row.addWidget(self.stop_button) 

614 

615 self.timeline = QWidget() 

616 self.timeline.setObjectName("Timeline") 

617 self.timeline_layout = QVBoxLayout(self.timeline) 

618 self.timeline_layout.setContentsMargins(0, 0, 4, 0) 

619 self.timeline_layout.setSpacing(6) 

620 self.empty = QLabel("Everything the AI does shows here: reviews (AI → Review Current File), " 

621 "explanations (Explain with AI), and questions and edits from the box below.") 

622 self.empty.setAlignment(Qt.AlignCenter) 

623 self.empty.setWordWrap(True) 

624 self.timeline_layout.addWidget(self.empty)