m2f-cli 0.2.0__py3-none-any.whl

m2f_cli/tui/workflows/fill_sorry.py

@@ -0,0 +1,627 @@
+"""Fill Sorry workflow - upload Lean project and fill sorry placeholders."""
+
+from __future__ import annotations
+
+import asyncio
+import difflib
+import io
+import os
+from datetime import datetime, timezone, timedelta
+from pathlib import Path
+
+from textual.widgets import Static, Input, DataTable
+from textual.containers import Vertical
+from textual.message import Message
+
+from m2f_cli.api_client import APIError, M2FClient
+from m2f_cli.i18n import t
+
+POLL_INTERVAL = 5
+TERMINAL_STATUSES = {"succeeded", "failed"}
+
+# Files/dirs to exclude from project zip
+EXCLUDE_PATTERNS = {
+    ".git", ".lake", "lake-packages", "build", "__pycache__",
+    ".DS_Store", "Thumbs.db", "node_modules",
+}
+
+
+def _find_project_root(lean_file: Path) -> Path | None:
+    """Walk up from a .lean file to find the project root (containing lakefile.lean)."""
+    current = lean_file.parent
+    for _ in range(10):
+        if (current / "lakefile.lean").exists() or (current / "lakefile.toml").exists():
+            return current
+        parent = current.parent
+        if parent == current:
+            break
+        current = parent
+    return None
+
+
+def _make_tar_gz(project_root: Path) -> bytes:
+    """Create an in-memory tar.gz of the project, excluding build artifacts."""
+    import tarfile as _tarfile
+    buf = io.BytesIO()
+
+    def _filter(tarinfo):
+        parts = set(tarinfo.name.replace(os.sep, '/').split('/'))
+        if parts & EXCLUDE_PATTERNS:
+            return None
+        return tarinfo
+
+    with _tarfile.open(fileobj=buf, mode='w:gz') as tar:
+        tar.add(str(project_root), arcname='.', filter=_filter)
+    return buf.getvalue()
+
+
+_BJT = timezone(timedelta(hours=8))
+
+
+def _fmt_time(iso_str: str) -> str:
+    """Convert ISO timestamp to Beijing time 'YYYY-MM-DD HH:MM:SS'."""
+    if not iso_str:
+        return ""
+    try:
+        dt = datetime.fromisoformat(iso_str.replace("Z", "+00:00"))
+        return dt.astimezone(_BJT).strftime("%Y-%m-%d %H:%M:%S")
+    except (ValueError, TypeError):
+        return iso_str[:19]
+
+
+def _status_label(status: str) -> str:
+    key = f"status_{status}"
+    label = t(key)
+    return label if label != key else status
+
+
+def _status_color(status: str) -> str:
+    colors = {
+        "queued": "#f0a020",
+        "template_creating": "#2080f0",
+        "compiling": "#2080f0",
+        "running": "#2080f0",
+        "succeeded": "#22c55e",
+        "failed": "#d03050",
+    }
+    return colors.get(status, "#999")
+
+
+class FillSorryFormWidget(Vertical, can_focus=True):
+    """Form to input target .lean file path."""
+
+    class Submitted(Message):
+        def __init__(self, lean_file: str, project_root: str, local_path: str) -> None:
+            self.lean_file = lean_file
+            self.project_root = project_root
+            self.local_path = local_path  # absolute path of the original .lean file
+            super().__init__()
+
+    class BackRequested(Message):
+        pass
+
+    DEFAULT_CSS = """
+    FillSorryFormWidget {
+        height: auto;
+        padding: 1 2;
+    }
+    FillSorryFormWidget .label {
+        margin: 1 0 0 0;
+    }
+    FillSorryFormWidget .hint {
+        color: #64748b;
+    }
+    """
+
+    def compose(self):
+        yield Static(f"[bold]{t('fill_sorry_new')}[/]")
+        yield Static(f"{t('fill_sorry_select_file')}:", classes="label")
+        yield Static(f"[dim]{t('fill_sorry_select_file_hint')}[/]", classes="hint")
+        yield Input(placeholder="path/to/file.lean", id="lean-file-input")
+        yield Static("", id="fs-project-info")
+        yield Static(f"[dim]{t('enter_submit_esc_back')}[/]")
+
+    def on_mount(self) -> None:
+        self.query_one("#lean-file-input", Input).focus()
+
+    def on_input_changed(self, event: Input.Changed) -> None:
+        if event.input.id != "lean-file-input":
+            return
+        path = Path(event.value.strip())
+        info = self.query_one("#fs-project-info", Static)
+        if path.exists() and path.suffix == ".lean":
+            root = _find_project_root(path)
+            if root:
+                info.update(f"[green]{t('fill_sorry_detected_project')}: {root}[/]")
+            else:
+                info.update(f"[yellow]{t('project_root_not_found')}[/]")
+        elif event.value.strip():
+            info.update(f"[red]{t('not_lean_file')}[/]" if not path.suffix == ".lean" else "")
+        else:
+            info.update("")
+
+    def on_input_submitted(self, event: Input.Submitted) -> None:
+        value = event.value.strip()
+        if not value:
+            return
+        path = Path(value)
+        if not path.exists() or path.suffix != ".lean":
+            return
+        root = _find_project_root(path)
+        if not root:
+            return
+        # Disable input immediately to prevent duplicate submits
+        inp = self.query_one("#lean-file-input", Input)
+        inp.disabled = True
+        self.query_one("#fs-project-info", Static).update(
+            f"[bold yellow]{t('fill_sorry_packaging')}...[/]"
+        )
+        # Make target_file relative to project root
+        abs_path = path.resolve()
+        try:
+            rel = abs_path.relative_to(root.resolve())
+        except ValueError:
+            rel = path.name
+        self.post_message(self.Submitted(
+            lean_file=str(rel).replace("\\", "/"),
+            project_root=str(root),
+            local_path=str(abs_path),
+        ))
+
+    def on_key(self, event) -> None:
+        if event.key == "escape":
+            self.post_message(self.BackRequested())
+
+
+class FillSorryProgressWidget(Vertical, can_focus=True):
+    """Monitor a fill sorry job's progress with auto-polling."""
+
+    class BackRequested(Message):
+        pass
+
+    DEFAULT_CSS = """
+    FillSorryProgressWidget {
+        height: 1fr;
+        padding: 1 2;
+    }
+    FillSorryProgressWidget #fs-diff-area {
+        margin-top: 1;
+        max-height: 30;
+        overflow-y: auto;
+    }
+    """
+
+    def __init__(
+        self,
+        job_id: str,
+        job_data: dict,
+        local_path: str | None = None,
+    ) -> None:
+        super().__init__()
+        self.job_id = job_id
+        self.job_data = job_data
+        self.local_path = local_path  # absolute path of original .lean file (None when viewed from history)
+        self._monitor_task: asyncio.Task | None = None
+        self._filled_content: str | None = None  # cached filled content after success
+        self._original_content: str | None = None
+
+    def compose(self):
+        target = self.job_data.get("target_file", "")
+        yield Static(f"[bold]{t('fill_sorry')}[/] [cyan]{target}[/]")
+        yield Static(f"[bold]{t('formalize_job_id')}:[/] [dim]{self.job_id[:8]}[/]")
+        if self.local_path:
+            yield Static(f"[dim]Local: {self.local_path}[/]")
+        yield Static("", id="fs-status-line")
+        yield Static("", id="fs-stage-line")
+        yield Static("", id="fs-message-line")
+        yield Static("", id="fs-diff-area")
+        yield Static(f"[dim]{t('fill_sorry_monitoring')}[/]", id="fs-hint-line")
+
+    def on_mount(self) -> None:
+        self._update_display()
+        self.focus()
+        status = self.job_data.get("status", "")
+        if status not in TERMINAL_STATUSES:
+            self._monitor_task = asyncio.create_task(self._poll())
+        elif status == "succeeded":
+            asyncio.create_task(self._load_and_render_diff())
+        else:
+            # Already failed — show failure reason immediately
+            fail_msg = self.job_data.get("message", "")
+            hint = self.query_one("#fs-hint-line", Static)
+            hint.update(
+                f"[red]{t('fill_sorry_finished')} ({_status_label(status)})[/]\n"
+                f"[dim]{fail_msg}[/]\n\n"
+                f"[dim]{t('esc_back_list')}[/]"
+            )
+
+    def _update_display(self) -> None:
+        status = self.job_data.get("status", "unknown")
+        stage = self.job_data.get("stage", "")
+        message = self.job_data.get("message", "")
+        color = _status_color(status)
+
+        self.query_one("#fs-status-line", Static).update(
+            f"[bold]{t('status')}:[/] [{color}]{_status_label(status)}[/]"
+        )
+        if stage:
+            self.query_one("#fs-stage-line", Static).update(
+                f"[bold]{t('formalize_stage')}:[/] {stage}"
+            )
+        if message:
+            self.query_one("#fs-message-line", Static).update(
+                f"[bold]{t('formalize_message')}:[/] {message}"
+            )
+
+    async def _poll(self) -> None:
+        try:
+            client = M2FClient()
+            while True:
+                await asyncio.sleep(POLL_INTERVAL)
+                try:
+                    data = client.sorry_status(self.job_id)
+                    self.job_data = data
+                    self._update_display()
+
+                    status = data.get("status", "")
+                    if status in TERMINAL_STATUSES:
+                        if status == "succeeded":
+                            await self._load_and_render_diff()
+                        else:
+                            hint = self.query_one("#fs-hint-line", Static)
+                            fail_msg = data.get("message", "")
+                            hint.update(
+                                f"[red]{t('fill_sorry_finished')} ({_status_label(status)})[/]\n"
+                                f"[dim]{fail_msg}[/]\n\n"
+                                f"[dim]{t('esc_back_list')}[/]"
+                            )
+                        break
+                except (APIError, Exception):
+                    pass
+        except asyncio.CancelledError:
+            pass
+
+    async def _load_and_render_diff(self) -> None:
+        """Fetch filled content from server, read local original, render diff."""
+        hint = self.query_one("#fs-hint-line", Static)
+        target_file = self.job_data.get("target_file") or ""
+        if not target_file:
+            hint.update(f"[yellow]{t('fill_sorry_no_target')}[/]")
+            return
+
+        hint.update(f"[dim]{t('fill_sorry_loading_diff')}[/]")
+        try:
+            client = M2FClient()
+            resp = client.sorry_read_file(self.job_id, target_file)
+            filled = resp.get("content", "")
+            self._filled_content = filled
+        except (APIError, Exception) as exc:
+            detail = getattr(exc, "detail", str(exc))
+            hint.update(f"[red]{t('fill_sorry_load_failed')}: {detail}[/]")
+            return
+
+        # Load original if we have the local path
+        if self.local_path and Path(self.local_path).exists():
+            try:
+                self._original_content = Path(self.local_path).read_text(encoding="utf-8")
+            except Exception:
+                self._original_content = None
+
+        self._render_diff()
+
+        if self.local_path:
+            hint.update(f"[dim]{t('fill_sorry_action_hint')}[/]")
+        else:
+            hint.update(f"[dim]{t('fill_sorry_action_hint_no_local')}[/]")
+
+    def _render_diff(self) -> None:
+        """Render git-style unified diff in the fs-diff-area widget."""
+        area = self.query_one("#fs-diff-area", Static)
+        filled = self._filled_content or ""
+
+        if self._original_content is None:
+            # No local file — just show the filled content
+            lines = filled.splitlines()
+            if len(lines) > 100:
+                preview = "\n".join(lines[:100]) + f"\n... ({len(lines) - 100} more lines)"
+            else:
+                preview = "\n".join(lines)
+            area.update(
+                f"[bold]{t('fill_sorry_filled_content')}:[/]\n[green]{preview}[/]"
+            )
+            return
+
+        # Git-style unified diff
+        diff_lines = list(difflib.unified_diff(
+            self._original_content.splitlines(),
+            filled.splitlines(),
+            fromfile=f"a/{self.job_data.get('target_file', 'file.lean')}",
+            tofile=f"b/{self.job_data.get('target_file', 'file.lean')}",
+            lineterm="",
+        ))
+
+        if not diff_lines:
+            area.update(f"[dim]{t('fill_sorry_no_changes')}[/]")
+            return
+
+        rendered: list[str] = []
+        for line in diff_lines:
+            # Escape Rich markup characters
+            escaped = line.replace("[", "\\[")
+            if line.startswith("+++") or line.startswith("---"):
+                rendered.append(f"[bold]{escaped}[/]")
+            elif line.startswith("@@"):
+                rendered.append(f"[cyan]{escaped}[/]")
+            elif line.startswith("+"):
+                rendered.append(f"[green]{escaped}[/]")
+            elif line.startswith("-"):
+                rendered.append(f"[red]{escaped}[/]")
+            else:
+                rendered.append(f"[dim]{escaped}[/]")
+
+        # Cap huge diffs
+        MAX_LINES = 200
+        if len(rendered) > MAX_LINES:
+            rendered = rendered[:MAX_LINES] + [f"[dim]... ({len(diff_lines) - MAX_LINES} more lines)[/]"]
+
+        area.update("\n".join(rendered))
+
+    def on_key(self, event) -> None:
+        key = (event.key or "").lower()
+        if key == "escape":
+            if self._monitor_task and not self._monitor_task.done():
+                self._monitor_task.cancel()
+            self.post_message(self.BackRequested())
+            return
+        if self.job_data.get("status") != "succeeded":
+            return
+        if key == "o":
+            asyncio.create_task(self._overwrite_local())
+        elif key == "s":
+            asyncio.create_task(self._save_as())
+        elif key == "d":
+            self._render_diff()  # re-render existing diff
+
+    async def _overwrite_local(self) -> None:
+        hint = self.query_one("#fs-hint-line", Static)
+        if not self.local_path or self._filled_content is None:
+            hint.update(f"[yellow]{t('fill_sorry_cannot_overwrite')}[/]")
+            return
+        try:
+            p = Path(self.local_path)
+            backup = p.with_suffix(p.suffix + ".bak")
+            if p.exists():
+                backup.write_bytes(p.read_bytes())
+            p.write_text(self._filled_content, encoding="utf-8")
+            hint.update(
+                f"[green]{t('fill_sorry_overwritten')}: {p}[/]\n"
+                f"[dim]Backup: {backup}[/]"
+            )
+        except Exception as exc:
+            hint.update(f"[red]{t('fill_sorry_overwrite_failed')}: {exc}[/]")
+
+    async def _save_as(self) -> None:
+        hint = self.query_one("#fs-hint-line", Static)
+        if self._filled_content is None:
+            hint.update(f"[yellow]{t('fill_sorry_no_content')}[/]")
+            return
+        target = self.job_data.get("target_file", "filled.lean")
+        # Save to current working directory preserving the file name
+        out_path = Path.cwd() / Path(target).name
+        try:
+            out_path.write_text(self._filled_content, encoding="utf-8")
+            hint.update(f"[green]{t('fill_sorry_saved')}: {out_path}[/]")
+        except Exception as exc:
+            hint.update(f"[red]{t('fill_sorry_save_failed')}: {exc}[/]")
+
+    def on_unmount(self) -> None:
+        if self._monitor_task and not self._monitor_task.done():
+            self._monitor_task.cancel()
+
+
+class FillSorryJobListWidget(Vertical, can_focus=True):
+    """Display a paginated list of fill sorry jobs."""
+
+    class BackRequested(Message):
+        pass
+
+    class JobSelected(Message):
+        def __init__(self, job_id: str, job_data: dict) -> None:
+            self.job_id = job_id
+            self.job_data = job_data
+            super().__init__()
+
+    class PageChanged(Message):
+        def __init__(self, page: int) -> None:
+            self.page = page
+            super().__init__()
+
+    DEFAULT_CSS = """
+    FillSorryJobListWidget {
+        height: 1fr;
+        padding: 1 2;
+    }
+    FillSorryJobListWidget DataTable {
+        height: 1fr;
+    }
+    """
+
+    def __init__(
+        self,
+        jobs: list[dict],
+        page: int = 1,
+        page_size: int = 20,
+        total: int = 0,
+    ) -> None:
+        super().__init__()
+        self._jobs = jobs
+        self.page = page
+        self.page_size = page_size
+        self.total = total
+
+    @property
+    def total_pages(self) -> int:
+        if self.total <= 0 or self.page_size <= 0:
+            return 1
+        return max(1, (self.total + self.page_size - 1) // self.page_size)
+
+    def compose(self):
+        yield Static(
+            f"[bold]{t('fill_sorry_history')}[/]  "
+            f"[dim]Enter=详情  Esc=返回  n/p=翻页  r=刷新[/]"
+        )
+        yield DataTable(id="fs-table")
+        yield Static(f"第 {self.page}/{self.total_pages} 页 · 共 {self.total} 条", id="fs-page-info")
+
+    def on_mount(self) -> None:
+        table = self.query_one("#fs-table", DataTable)
+        table.add_columns(
+            t("col_name"), t("col_status"), t("col_stage"),
+            t("col_message"), t("col_created"),
+        )
+        table.cursor_type = "row"
+        for job in self._jobs:
+            name = job.get("statement_prompt", "")[:50]
+            if len(job.get("statement_prompt", "")) > 50:
+                name += "..."
+            status = job.get("status", "")
+            color = _status_color(status)
+            table.add_row(
+                name,
+                f"[{color}]{_status_label(status)}[/]",
+                job.get("stage", ""),
+                (job.get("message", "") or "")[:30],
+                _fmt_time(job.get("created_at", "")),
+                key=job.get("id", ""),
+            )
+        table.focus()
+
+    def on_data_table_row_selected(self, event: DataTable.RowSelected) -> None:
+        row_key = str(event.row_key.value)
+        for job in self._jobs:
+            if job.get("id") == row_key:
+                self.post_message(self.JobSelected(job_id=row_key, job_data=job))
+                return
+
+    def on_key(self, event) -> None:
+        key = (event.key or "").lower()
+        if key == "escape":
+            self.post_message(self.BackRequested())
+        elif key == "n":
+            if self.page < self.total_pages:
+                self.post_message(self.PageChanged(page=self.page + 1))
+        elif key == "p":
+            if self.page > 1:
+                self.post_message(self.PageChanged(page=self.page - 1))
+        elif key == "r":
+            self.post_message(self.PageChanged(page=self.page))
+
+
+async def run_fill_sorry_submit(
+    app, lean_file: str, project_root: str, local_path: str | None = None,
+) -> None:
+    """Package project as tar.gz, upload via sorry-cli, list sorries, start run."""
+    container = app.query_one("#main-scroll")
+
+    status_widget = Static(f"[bold]{t('fill_sorry_packaging')}[/]")
+    container.mount(status_widget)
+
+    # Step 1: Package project as tar.gz
+    try:
+        root = Path(project_root)
+        tar_data = _make_tar_gz(root)
+        size_kb = len(tar_data) / 1024
+        status_widget.update(
+            f"[bold]{t('fill_sorry_uploading')}[/] ({size_kb:.0f} KB)"
+        )
+    except Exception as exc:
+        from m2f_cli.tui.components.message import MessageWidget
+        container.mount(MessageWidget(f"{t('fill_sorry_submit_failed')}: {exc}", "error"))
+        container.mount(Static(f"[dim]{t('press_any_key_back')}[/]"))
+        return
+
+    # Step 2: Upload via sorry-cli
+    try:
+        client = M2FClient()
+        data = client.sorry_upload(tar_data, project_name=Path(project_root).name)
+    except (APIError, Exception) as exc:
+        from m2f_cli.tui.components.message import MessageWidget
+        detail = exc.detail if isinstance(exc, APIError) else str(exc)
+        container.mount(MessageWidget(f"{t('fill_sorry_submit_failed')}: {detail}", "error"))
+        container.mount(Static(f"[dim]{t('press_any_key_back')}[/]"))
+        return
+
+    job_id = data.get("id", "")
+    status_widget.update(
+        f"[bold green]{t('fill_sorry_submitted')}[/] {t('formalize_job_id')}: [cyan]{job_id[:8]}[/]"
+    )
+
+    # Step 3: List sorries → auto-start run with first sorry
+    try:
+        sorries_data = client.sorry_list_sorries(job_id, lean_file)
+        sorry_count = sorries_data.get("count", 0)
+        if sorry_count > 0:
+            sorries = sorries_data.get("sorries", [])
+            first = sorries[0] if sorries else {}
+            container.mount(Static(
+                f"[bold]发现 {sorry_count} 个 sorry[/]，"
+                f"自动处理第 1 个 (line {first.get('line', '?')} — {first.get('declaration', '')[:50]})"
+            ))
+        else:
+            container.mount(Static(f"[yellow]该文件没有 sorry[/]"))
+            container.mount(Static(f"[dim]{t('press_any_key_back')}[/]"))
+            return
+    except (APIError, Exception):
+        container.mount(Static("[dim]无法列出 sorry，使用 first 模式[/]"))
+
+    # Step 4: Start run (compile + prove) via Worker
+    try:
+        run_payload = {
+            "lean_file": lean_file,
+            "target_sorry": {"mode": "first"},
+            "strict_target_only": True,
+        }
+        client.sorry_run(job_id, run_payload)
+    except (APIError, Exception) as exc:
+        from m2f_cli.tui.components.message import MessageWidget
+        detail = exc.detail if isinstance(exc, APIError) else str(exc)
+        container.mount(MessageWidget(f"{t('fill_sorry_submit_failed')}: {detail}", "error"))
+        container.mount(Static(f"[dim]{t('press_any_key_back')}[/]"))
+        return
+
+    # Show progress widget — polls sorry_status
+    from m2f_cli.tui.components.logo import LogoWidget
+    container.remove_children()
+    container.mount(LogoWidget())
+    container.mount(FillSorryProgressWidget(
+        job_id=job_id, job_data=data, local_path=local_path,
+    ))
+
+
+def fetch_and_show_fill_sorry_jobs(app, page: int = 1, page_size: int = 20) -> None:
+    """Fetch paginated CLI fill sorry job list and display."""
+    from m2f_cli.tui.components.message import MessageWidget
+
+    try:
+        client = M2FClient()
+        result = client.list_cli_jobs(page=page, page_size=page_size)
+        jobs = result.get("items", [])
+        total = result.get("total", len(jobs))
+    except APIError as exc:
+        app._clear_and_mount(MessageWidget(f"Error: {exc.detail}", "error"))
+        return
+    except Exception as exc:
+        app._clear_and_mount(MessageWidget(f"{t('connection_error')}: {exc}", "error"))
+        return
+
+    if not jobs and page == 1:
+        from textual.widgets import Static
+        app._clear_and_mount(
+            Static(f"[dim]{t('no_fill_sorry_jobs')}[/]"),
+            Static(f"\n[dim]{t('press_any_key_back')}[/]"),
+        )
+        return
+
+    app._clear_and_mount(FillSorryJobListWidget(
+        jobs=jobs, page=page, page_size=page_size, total=total,
+    ))