siftcode 0.3.0__py3-none-any.whl

siftcode/gui/analyzer_view.py

@@ -0,0 +1,560 @@
+"""
+AnalyzerView — runs the analysis pipeline in a background thread.
+
+Uses Gio.Task + Gio.Cancellable to run the analyzer without freezing
+the UI, and reports progress via GLib.idle_add.
+"""
+
+from __future__ import annotations
+
+import logging
+import subprocess
+from datetime import datetime
+from pathlib import Path
+
+import gi
+
+gi.require_version("Gtk", "4.0")
+gi.require_version("Adw", "1")
+
+from gi.repository import Adw, Gio, GLib, Gtk  # noqa: E402
+
+from siftcode.core.analyzer import Findings, Progress, ProjectAnalyzer  # noqa: E402
+from siftcode.core.config import ProjectConfig  # noqa: E402
+from siftcode.core.llm import LLMError, OllamaClient  # noqa: E402
+from siftcode.gui.widgets.log_view import LogView  # noqa: E402
+
+
+logger = logging.getLogger(__name__)
+
+
+# Default output base directory
+OUTPUT_BASE = Path.home() / "siftcode-output"
+
+
+class AnalyzerView(Adw.Bin):
+    """
+    A view for running analysis and showing progress.
+
+    Callbacks:
+        set_on_back(cb)  — cb() called when Back is pressed
+    """
+
+    def __init__(self) -> None:
+        super().__init__()
+
+        self._config: ProjectConfig | None = None
+        self._on_back = None
+
+        # Analysis state
+        self._cancellable: Gio.Cancellable | None = None
+        self._running = False
+        self._started_at: datetime | None = None
+        self._output_dir: Path | None = None
+        self._guide_path: Path | None = None
+        self._findings_path: Path | None = None
+        self._analyzer: ProjectAnalyzer | None = None
+
+        # --- Toolbar view with header -------------------------------------
+        self._toolbar_view = Adw.ToolbarView()
+
+        self._header = Adw.HeaderBar()
+        self._title = Adw.WindowTitle(title="Analyzer", subtitle="")
+        self._header.set_title_widget(self._title)
+
+        # Left: back button
+        self._back_button = Gtk.Button.new_from_icon_name("go-previous-symbolic")
+        self._back_button.set_tooltip_text("Back")
+        self._back_button.connect("clicked", self._on_back_clicked)
+        self._header.pack_start(self._back_button)
+
+        # Right: open guide button (visible after completion)
+        self._open_guide_button = Gtk.Button(label="Open guide")
+        self._open_guide_button.set_tooltip_text("Preview the generated guide")
+        self._open_guide_button.set_visible(False)
+        self._open_guide_button.connect("clicked", self._on_open_guide_clicked)
+        self._header.pack_end(self._open_guide_button)
+
+        # Right: open folder button (visible after completion)
+        self._open_folder_button = Gtk.Button.new_from_icon_name(
+            "folder-open-symbolic"
+        )
+        self._open_folder_button.set_tooltip_text("Open output folder")
+        self._open_folder_button.set_visible(False)
+        self._open_folder_button.connect("clicked", self._on_open_folder_clicked)
+        self._header.pack_end(self._open_folder_button)
+
+        # Right: analyze button (visible when idle)
+        self._analyze_button = Gtk.Button(label="Analyze")
+        self._analyze_button.add_css_class("suggested-action")
+        self._analyze_button.connect("clicked", self._on_analyze_clicked)
+        self._header.pack_end(self._analyze_button)
+
+        # Right: cancel button (visible during analysis)
+        self._cancel_button = Gtk.Button(label="Cancel")
+        self._cancel_button.add_css_class("destructive-action")
+        self._cancel_button.set_visible(False)
+        self._cancel_button.connect("clicked", self._on_cancel_clicked)
+        self._header.pack_end(self._cancel_button)
+
+        self._toolbar_view.add_top_bar(self._header)
+
+        # --- Content ------------------------------------------------------
+        content = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=18)
+        content.set_margin_top(24)
+        content.set_margin_bottom(24)
+        content.set_margin_start(24)
+        content.set_margin_end(24)
+
+        # Status group
+        status_group = Adw.PreferencesGroup()
+        status_group.set_title("Status")
+
+        self._status_row = Adw.ActionRow()
+        self._status_row.set_title("Ready to analyze")
+        self._status_row.set_subtitle("Press Analyze to start")
+        self._status_icon = Gtk.Image.new_from_icon_name("media-playback-start-symbolic")
+        self._status_icon.set_pixel_size(20)
+        self._status_row.add_prefix(self._status_icon)
+        status_group.add(self._status_row)
+
+        self._progress_row = Adw.ActionRow()
+        self._progress_row.set_title("Progress")
+
+        self._progress_bar = Gtk.ProgressBar()
+        self._progress_bar.set_valign(Gtk.Align.CENTER)
+        self._progress_bar.set_size_request(300, -1)
+        self._progress_bar.set_show_text(True)
+        self._progress_row.add_suffix(self._progress_bar)
+        status_group.add(self._progress_row)
+
+        content.append(status_group)
+
+        # Results group (hidden until analysis completes)
+        self._results_group = Adw.PreferencesGroup()
+        self._results_group.set_title("Results")
+        self._results_group.set_visible(False)
+
+        self._files_row = Adw.ActionRow()
+        self._files_row.set_title("Files analyzed")
+        self._files_row.set_subtitle("—")
+        self._files_row.add_prefix(
+            Gtk.Image.new_from_icon_name("text-x-generic-symbolic")
+        )
+        self._results_group.add(self._files_row)
+
+        self._directories_row = Adw.ActionRow()
+        self._directories_row.set_title("Directories summarized")
+        self._directories_row.set_subtitle("—")
+        self._directories_row.add_prefix(
+            Gtk.Image.new_from_icon_name("folder-symbolic")
+        )
+        self._results_group.add(self._directories_row)
+
+        self._errors_row = Adw.ActionRow()
+        self._errors_row.set_title("Errors")
+        self._errors_row.set_subtitle("—")
+        self._errors_row.add_prefix(
+            Gtk.Image.new_from_icon_name("dialog-warning-symbolic")
+        )
+        self._results_group.add(self._errors_row)
+
+        self._elapsed_row = Adw.ActionRow()
+        self._elapsed_row.set_title("Duration")
+        self._elapsed_row.set_subtitle("—")
+        self._elapsed_row.add_prefix(
+            Gtk.Image.new_from_icon_name("preferences-system-time-symbolic")
+        )
+        self._results_group.add(self._elapsed_row)
+
+        self._output_row = Adw.ActionRow()
+        self._output_row.set_title("Output folder")
+        self._output_row.set_subtitle("—")
+        self._output_row.set_activatable(True)
+        self._output_row.add_prefix(
+            Gtk.Image.new_from_icon_name("folder-open-symbolic")
+        )
+        self._output_row.connect(
+            "activated", lambda *_: self._on_open_folder_clicked(None)
+        )
+        self._results_group.add(self._output_row)
+
+        content.append(self._results_group)
+
+        # Log group
+        log_group = Adw.PreferencesGroup()
+        log_group.set_title("Log")
+
+        self._log_view = LogView()
+        log_group.add(self._log_view)
+
+        content.append(log_group)
+
+        # Wrap in scrolled window
+        scrolled = Gtk.ScrolledWindow()
+        scrolled.set_vexpand(True)
+        scrolled.set_child(content)
+        self._toolbar_view.set_content(scrolled)
+
+        self.set_child(self._toolbar_view)
+
+        # Start with a "loaded" message
+        self._log_view.append("Analyzer ready", "info")
+
+    # ------------------------------------------------------------------
+    # Public API
+    # ------------------------------------------------------------------
+
+    def set_on_back(self, callback) -> None:
+        self._on_back = callback
+
+    def load_config(self, config: ProjectConfig) -> None:
+        """Prepare the view for a given project."""
+        if self._running:
+            self._cancel_analysis()
+
+        self._config = config
+        self._title.set_title(f"Analyzer — {config.name}")
+        self._title.set_subtitle(str(config.path))
+
+        self._set_status(
+            "Ready to analyze",
+            f"Model: {config.model.name}",
+            "media-playback-start-symbolic",
+        )
+        self._progress_bar.set_fraction(0.0)
+        self._progress_bar.set_text("0 %")
+
+        # Reset results
+        self._results_group.set_visible(False)
+        self._output_dir = None
+        self._guide_path = None
+        self._findings_path = None
+
+        # Reset buttons
+        self._analyze_button.set_visible(True)
+        self._cancel_button.set_visible(False)
+        self._open_guide_button.set_visible(False)
+        self._open_folder_button.set_visible(False)
+        self._back_button.set_sensitive(True)
+
+        self._log_view.clear()
+        self._log_view.append(f"Loaded project '{config.name}'", "info")
+        self._log_view.append(f"Path: {config.path}", "info")
+        self._log_view.append(f"Model: {config.model.name}", "info")
+
+    def update_progress(self, progress: Progress) -> None:
+        """Called from the analysis worker (via GLib.idle_add)."""
+        self._progress_bar.set_fraction(progress.fraction)
+        self._progress_bar.set_text(f"{int(progress.fraction * 100)} %")
+
+        if progress.message:
+            self._set_status(
+                progress.message,
+                f"Stage: {progress.stage}",
+                "emblem-synchronizing-symbolic",
+            )
+            self._log_view.append(progress.message, "info")
+
+    def set_finished(self, findings: Findings, output_dir: Path) -> None:
+        """Called when analysis completes successfully."""
+        elapsed_secs = 0
+        if self._started_at is not None:
+            elapsed_secs = int((datetime.now() - self._started_at).total_seconds())
+
+        self._set_status(
+            f"Analysis complete in {elapsed_secs} s",
+            f"{len(findings.files)} files, "
+            f"{len(findings.directories)} directories, "
+            f"{len(findings.errors)} errors",
+            "emblem-ok-symbolic",
+        )
+        self._progress_bar.set_fraction(1.0)
+        self._progress_bar.set_text("100 %")
+
+        # Update results group
+        self._files_row.set_subtitle(str(len(findings.files)))
+        self._directories_row.set_subtitle(str(len(findings.directories)))
+        self._errors_row.set_subtitle(str(len(findings.errors)))
+        self._elapsed_row.set_subtitle(f"{elapsed_secs} seconds")
+
+        # Show a shortened path with ~ for the home directory
+        display_path = str(output_dir)
+        home = str(Path.home())
+        if display_path.startswith(home):
+            display_path = "~" + display_path[len(home):]
+        self._output_row.set_subtitle(display_path)
+        self._results_group.set_visible(True)
+
+        # Show action buttons
+        self._analyze_button.set_visible(True)
+        self._analyze_button.set_label("Analyze again")
+        self._cancel_button.set_visible(False)
+        self._open_guide_button.set_visible(True)
+        self._open_folder_button.set_visible(True)
+
+        # Log
+        self._log_view.append(f"✓ Analysis complete in {elapsed_secs} s", "success")
+        self._log_view.append(f"Files:       {len(findings.files)}", "info")
+        self._log_view.append(f"Directories: {len(findings.directories)}", "info")
+        self._log_view.append(f"Errors:      {len(findings.errors)}", "info")
+        self._log_view.append(f"Output:      {output_dir}", "info")
+
+        if findings.errors:
+            for err in findings.errors[:10]:
+                self._log_view.append(
+                    f"⚠ {err.get('stage', '?')}: "
+                    f"{err.get('path', '?')} — {err.get('error', '?')}",
+                    "warning",
+                )
+
+    def set_error(self, message: str) -> None:
+        """Called when analysis fails."""
+        self._set_status("Error", message, "dialog-error-symbolic")
+        self._log_view.append(f"✗ {message}", "error")
+
+        self._analyze_button.set_visible(True)
+        self._analyze_button.set_label("Analyze")
+        self._cancel_button.set_visible(False)
+        self._open_guide_button.set_visible(False)
+        self._open_folder_button.set_visible(False)
+        self._back_button.set_sensitive(True)
+
+    # ------------------------------------------------------------------
+    # Analysis: start / cancel / worker
+    # ------------------------------------------------------------------
+
+    def _on_analyze_clicked(self, _button) -> None:
+        if self._config is None:
+            return
+        if self._running:
+            return
+        self._start_analysis()
+
+    def _on_cancel_clicked(self, _button) -> None:
+        if self._running:
+            self._log_view.append("Cancelling...", "warning")
+            self._cancel_analysis()
+
+    def _start_analysis(self) -> None:
+        """Launch the analysis in a background thread via Gio.Task."""
+        if self._config is None or self._running:
+            return
+
+        self._running = True
+        self._started_at = datetime.now()
+        self._cancellable = Gio.Cancellable()
+
+        # Timestamp first so folders sort chronologically:
+        #   2026-10-16_21-55-42_<slug>
+        timestamp = self._started_at.strftime("%Y-%m-%d_%H-%M-%S")
+        slug = "".join(
+            c if c.isalnum() or c in "-_" else "-"
+            for c in self._config.name.lower().replace(" ", "-")
+        )
+        while "--" in slug:
+            slug = slug.replace("--", "-")
+        slug = slug.strip("-") or "project"
+
+        self._output_dir = OUTPUT_BASE / f"{timestamp}_{slug}"
+        self._output_dir.mkdir(parents=True, exist_ok=True)
+        self._guide_path = self._output_dir / "guide.md"
+        self._findings_path = self._output_dir / "findings.json"
+
+        self._log_view.append(
+            f"Starting analysis (output: {self._output_dir})", "info"
+        )
+
+        # Update UI
+        self._analyze_button.set_visible(False)
+        self._open_guide_button.set_visible(False)
+        self._open_folder_button.set_visible(False)
+        self._cancel_button.set_visible(True)
+        self._back_button.set_sensitive(False)
+        self._results_group.set_visible(False)
+        self._progress_bar.set_fraction(0.0)
+
+        self._set_status(
+            "Starting...",
+            f"Model: {self._config.model.name}",
+            "emblem-synchronizing-symbolic",
+        )
+
+        task = Gio.Task.new(self, self._cancellable, self._on_task_done, None)
+        task.set_return_on_cancel(True)
+        task.run_in_thread(self._analysis_worker)
+
+    def _analysis_worker(
+        self,
+        task: Gio.Task,
+        source_object,
+        task_data,
+        cancellable: Gio.Cancellable,
+    ) -> None:
+        """Runs on a worker thread. Do NOT touch GTK widgets here."""
+        try:
+            if self._config is None:
+                task.return_error(GLib.Error("No project configured"))
+                return
+
+            client = OllamaClient(self._config.model)
+            analyzer = ProjectAnalyzer(self._config, client)
+            self._analyzer = analyzer
+
+            for progress in analyzer.analyze_project():
+                if cancellable.is_cancelled():
+                    task.return_error(GLib.Error("Cancelled by user"))
+                    return
+                GLib.idle_add(self.update_progress, progress)
+
+            # Save results
+            if self._output_dir is not None:
+                analyzer.findings.save(self._findings_path)
+                self._guide_path.write_text(
+                    analyzer.findings.guide, encoding="utf-8"
+                )
+
+            task.return_value(analyzer.findings)
+
+        except LLMError as e:
+            logger.error(f"LLM error during analysis: {e}")
+            task.return_error(GLib.Error(str(e)))
+        except Exception as e:
+            logger.exception(f"Unexpected error during analysis: {e}")
+            task.return_error(GLib.Error(f"Unexpected error: {e}"))
+
+    def _on_task_done(
+        self,
+        source_object,
+        result: Gio.AsyncResult,
+        user_data,
+    ) -> None:
+        """Runs on the main thread when the worker finishes."""
+        self._running = False
+        self._cancel_button.set_visible(False)
+        self._back_button.set_sensitive(True)
+
+        # Check if the user cancelled before looking at the result
+        if self._cancellable is not None and self._cancellable.is_cancelled():
+            self._analyze_button.set_visible(True)
+            self._analyze_button.set_label("Analyze")
+            self._log_view.append("✗ Analysis cancelled by user", "warning")
+            self._set_status(
+                "Cancelled",
+                "Analysis was cancelled",
+                "process-stop-symbolic",
+            )
+            self._progress_bar.set_fraction(0.0)
+            self._progress_bar.set_text("—")
+            self._cancellable = None
+            return
+
+        try:
+            findings = result.propagate_value().value
+        except GLib.Error as e:
+            message = e.message
+            if "Cancelled" in message:
+                self._analyze_button.set_visible(True)
+                self._analyze_button.set_label("Analyze")
+                self._log_view.append("✗ Analysis cancelled by user", "warning")
+                self._set_status(
+                    "Cancelled",
+                    "Analysis was cancelled",
+                    "process-stop-symbolic",
+                )
+                self._progress_bar.set_fraction(0.0)
+                self._progress_bar.set_text("—")
+            else:
+                self._analyze_button.set_visible(True)
+                self._analyze_button.set_label("Analyze")
+                self.set_error(message)
+            self._cancellable = None
+            return
+
+        if self._output_dir is None:
+            self.set_error("Analysis completed but no output directory")
+            self._cancellable = None
+            return
+
+        # Update last_run timestamp in the project config and save it
+        if self._config is not None:
+            try:
+                from siftcode.core.config import save_project
+                self._config.last_run = datetime.now().isoformat(timespec="seconds")
+                save_project(self._config)
+                logger.info(f"Updated last_run for '{self._config.name}'")
+            except Exception as e:
+                logger.warning(f"Could not save last_run: {e}")
+
+        self.set_finished(findings, self._output_dir)
+        self._cancellable = None
+
+    def _cancel_analysis(self) -> None:
+        """Request cancellation of the current analysis."""
+        if self._cancellable is not None:
+            self._cancellable.cancel()
+
+    # ------------------------------------------------------------------
+    # Open guide / folder
+    # ------------------------------------------------------------------
+
+    def _on_open_guide_clicked(self, _button) -> None:
+        """Open the guide in an integrated Markdown preview window."""
+        if self._guide_path is None or not self._guide_path.exists():
+            self._log_view.append("Guide file not found", "warning")
+            return
+
+        from siftcode.gui.guide_window import GuideWindow
+
+        title = "Guide"
+        if self._config is not None:
+            title = f"Guide — {self._config.name}"
+
+        window = GuideWindow(self.get_root(), title, self._guide_path)
+        window.present()
+
+    def _on_open_folder_clicked(self, _button) -> None:
+        """Open the output folder in the system's file manager."""
+        if self._output_dir is None or not self._output_dir.exists():
+            self._log_view.append("Output folder not found", "warning")
+            return
+        self._open_with_system_default(self._output_dir)
+
+    def _open_with_system_default(self, path: Path) -> None:
+        """Open a file or folder with the desktop's default application."""
+        try:
+            subprocess.Popen(
+                ["xdg-open", str(path)],
+                stdout=subprocess.DEVNULL,
+                stderr=subprocess.DEVNULL,
+            )
+            self._log_view.append(f"Opened: {path}", "info")
+        except FileNotFoundError:
+            self._log_view.append(
+                "xdg-open not found — is your desktop environment complete?",
+                "warning",
+            )
+        except Exception as e:
+            self._log_view.append(f"Could not open {path}: {e}", "error")
+
+    # ------------------------------------------------------------------
+    # Internal
+    # ------------------------------------------------------------------
+
+    def _set_status(self, title: str, subtitle: str, icon_name: str) -> None:
+        self._status_row.set_title(title)
+        self._status_row.set_subtitle(subtitle)
+        self._status_icon.set_from_icon_name(icon_name)
+
+    # ------------------------------------------------------------------
+    # Signals
+    # ------------------------------------------------------------------
+
+    def _on_back_clicked(self, _button) -> None:
+        if self._running:
+            self._log_view.append(
+                "Please cancel the analysis before leaving", "warning"
+            )
+            return
+        if self._on_back:
+            self._on_back()