siftcode 0.3.0__py3-none-any.whl

siftcode/gui/window.py

@@ -0,0 +1,446 @@
+"""
+Main application window for Siftcode.
+
+Phase 4: Welcome / Projects / Settings / Analyzer views via a Gtk.Stack.
+"""
+
+from __future__ import annotations
+
+import logging
+from pathlib import Path
+
+import gi
+
+gi.require_version("Gtk", "4.0")
+gi.require_version("Adw", "1")
+
+from gi.repository import Adw, Gio, Gtk  # noqa: E402
+
+from siftcode.core.config import (  # noqa: E402
+    PROJECTS_DIR,
+    ProjectConfig,
+    delete_project,
+    list_projects,
+    save_project,
+)
+from siftcode.gui.analyzer_view import AnalyzerView  # noqa: E402
+from siftcode.gui.project_list import ProjectListView  # noqa: E402
+from siftcode.gui.settings_view import SettingsView  # noqa: E402
+
+
+logger = logging.getLogger(__name__)
+
+
+class MainWindow(Adw.ApplicationWindow):
+    """The main window of Siftcode."""
+
+    def __init__(self, **kwargs) -> None:
+        super().__init__(**kwargs)
+
+        self.set_title("Siftcode")
+        self.set_default_size(900, 640)
+        self.set_size_request(600, 400)
+
+        # Active row reference for context menu actions
+        self._active_row = None
+
+        # --- Window-level actions for the row context menu ------------
+        action_group = Gio.SimpleActionGroup()
+
+        edit_row_action = Gio.SimpleAction.new("edit-row", None)
+        edit_row_action.connect("activate", self._on_edit_row_action)
+        action_group.add_action(edit_row_action)
+
+        open_guide_action = Gio.SimpleAction.new("open-latest-guide", None)
+        open_guide_action.connect("activate", self._on_open_latest_guide)
+        action_group.add_action(open_guide_action)
+
+        open_folder_action = Gio.SimpleAction.new("open-output-folder", None)
+        open_folder_action.connect("activate", self._on_open_output_folder)
+        action_group.add_action(open_folder_action)
+
+        delete_row_action = Gio.SimpleAction.new("delete-row", None)
+        delete_row_action.connect("activate", self._on_delete_row_action)
+        action_group.add_action(delete_row_action)
+
+        self.insert_action_group("window", action_group)
+
+        # Root layout
+        toolbar_view = Adw.ToolbarView()
+
+        # Main header bar (shown on Welcome / Projects views)
+        self.main_header = Adw.HeaderBar()
+        self.main_header.set_title_widget(
+            Adw.WindowTitle(title="Siftcode", subtitle="")
+        )
+
+        self.add_button = Gtk.Button.new_from_icon_name("list-add-symbolic")
+        self.add_button.set_tooltip_text("Add a project")
+        self.add_button.connect("clicked", self._on_add_clicked)
+        self.main_header.pack_start(self.add_button)
+
+        menu_button = Gtk.MenuButton()
+        menu_button.set_icon_name("open-menu-symbolic")
+        menu_button.set_tooltip_text("Main menu")
+
+        menu = Gio.Menu()
+        menu.append("About Siftcode", "app.about")
+        menu.append("Quit", "app.quit")
+        menu_button.set_menu_model(menu)
+
+        self.main_header.pack_end(menu_button)
+
+        toolbar_view.add_top_bar(self.main_header)
+
+        # Content: stack of views
+        self.stack = Gtk.Stack()
+        self.stack.set_transition_type(Gtk.StackTransitionType.CROSSFADE)
+
+        # Welcome
+        self.stack.add_named(self._build_welcome_view(), "welcome")
+
+        # Project list
+        self.project_list = ProjectListView()
+        self.project_list.set_on_project_activated(self._on_project_activated)
+        self.stack.add_named(self.project_list, "projects")
+
+        # Analyzer view (created before settings, since settings hands off to it)
+        self.analyzer_view = AnalyzerView()
+        self.analyzer_view.set_on_back(self._on_analyzer_back)
+        self.stack.add_named(self.analyzer_view, "analyzer")
+
+        # Settings view
+        self.settings_view = SettingsView()
+        self.settings_view.set_on_saved(self._on_settings_saved)
+        self.settings_view.set_on_cancelled(self._on_settings_cancelled)
+        self.settings_view.set_on_deleted(self._on_settings_deleted)
+        self.settings_view.set_on_analyze(self._on_start_analysis)  # ← UUSI
+        self.stack.add_named(self.settings_view, "settings")
+
+        try:
+            has_projects = len(list_projects()) > 0
+        except Exception:
+            has_projects = False
+
+        self.stack.set_visible_child_name("projects" if has_projects else "welcome")
+
+        toolbar_view.set_content(self.stack)
+
+        self.set_content(toolbar_view)
+
+    # ------------------------------------------------------------------
+    # Welcome view
+    # ------------------------------------------------------------------
+
+    def _build_welcome_view(self) -> Gtk.Widget:
+        box = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=12)
+        box.set_margin_top(48)
+        box.set_margin_bottom(48)
+        box.set_margin_start(48)
+        box.set_margin_end(48)
+        box.set_valign(Gtk.Align.CENTER)
+        box.set_halign(Gtk.Align.CENTER)
+
+        icon = Gtk.Image.new_from_icon_name("system-search-symbolic")
+        icon.set_pixel_size(96)
+        icon.add_css_class("welcome-icon")
+        box.append(icon)
+
+        title = Gtk.Label(label="Siftcode")
+        title.add_css_class("welcome-title")
+        box.append(title)
+
+        subtitle = Gtk.Label(
+            label="Local LLM-powered code analysis and developer guide generator",
+            wrap=True,
+            justify=Gtk.Justification.CENTER,
+        )
+        subtitle.add_css_class("welcome-subtitle")
+        box.append(subtitle)
+
+        box.append(Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=24))
+
+        try:
+            project_count = len(list_projects())
+        except Exception:
+            project_count = 0
+
+        stats = self._build_stats_row(
+            ("Saved projects", str(project_count)),
+            ("Config dir", str(PROJECTS_DIR).replace(str(Path.home()), "~")),
+        )
+        box.append(stats)
+
+        return box
+
+    def _build_stats_row(self, *pairs: tuple[str, str]) -> Gtk.Widget:
+        row = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL, spacing=48)
+        row.set_halign(Gtk.Align.CENTER)
+        row.set_margin_top(24)
+
+        for label, value in pairs:
+            col = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=4)
+            col.set_halign(Gtk.Align.CENTER)
+
+            value_label = Gtk.Label(label=value)
+            value_label.add_css_class("stat-value")
+            col.append(value_label)
+
+            name_label = Gtk.Label(label=label)
+            name_label.add_css_class("stat-label")
+            col.append(name_label)
+
+            row.append(col)
+
+        return row
+
+    # ------------------------------------------------------------------
+    # Row context actions
+    # ------------------------------------------------------------------
+
+    def _on_edit_row_action(self, _action, _param) -> None:
+        row = self._active_row
+        if row is None:
+            return
+        config = getattr(row, "config", None)
+        if config is not None:
+            self._on_project_activated(config)
+
+    def _project_slug(self, name: str) -> str:
+        """Convert a project name to the same slug used in output folders."""
+        slug = "".join(
+            c if c.isalnum() or c in "-_" else "-"
+            for c in name.lower().replace(" ", "-")
+        )
+        while "--" in slug:
+            slug = slug.replace("--", "-")
+        return slug.strip("-") or "project"
+
+    def _find_latest_output(self, config: ProjectConfig) -> "Path | None":
+        """Return the most recent output folder for the given project."""
+        from pathlib import Path
+
+        output_base = Path.home() / "siftcode-output"
+        if not output_base.exists():
+            return None
+
+        slug = self._project_slug(config.name)
+
+        # Match both old (slug_timestamp) and new (timestamp_slug) formats
+        candidates = [
+            d for d in output_base.iterdir()
+            if d.is_dir() and (d.name.endswith(f"_{slug}") or d.name.startswith(f"{slug}_"))
+        ]
+        if not candidates:
+            return None
+
+        # Sort by name (timestamp prefix in new format, suffix in old)
+        candidates.sort(key=lambda d: d.name, reverse=True)
+        return candidates[0]
+
+    def _on_open_latest_guide(self, _action, _param) -> None:
+        """Open the latest guide for the active row's project."""
+        row = self._active_row
+        if row is None:
+            return
+        config = getattr(row, "config", None)
+        if config is None:
+            return
+
+        latest = self._find_latest_output(config)
+        if latest is None:
+            return
+
+        guide_path = latest / "guide.md"
+        if not guide_path.exists():
+            return
+
+        from siftcode.gui.guide_window import GuideWindow
+
+        window = GuideWindow(self, f"Guide — {config.name}", guide_path)
+        window.present()
+
+    def _on_open_output_folder(self, _action, _param) -> None:
+        """Open the latest output folder for the active row's project."""
+        import subprocess
+
+        row = self._active_row
+        if row is None:
+            return
+        config = getattr(row, "config", None)
+        if config is None:
+            return
+
+        latest = self._find_latest_output(config)
+        if latest is None:
+            return
+
+        try:
+            subprocess.Popen(
+                ["xdg-open", str(latest)],
+                stdout=subprocess.DEVNULL,
+                stderr=subprocess.DEVNULL,
+            )
+        except Exception:
+            pass
+
+    def _on_delete_row_action(self, _action, _param) -> None:
+        row = self._active_row
+        if row is None:
+            return
+        config = getattr(row, "config", None)
+        if config is None:
+            return
+
+        dialog = Adw.MessageDialog.new(
+            self,
+            "Delete project?",
+            f"Are you sure you want to delete '{config.name}'?\n\n"
+            f"This removes the saved configuration, not the project files.",
+        )
+        dialog.add_response("cancel", "Cancel")
+        dialog.add_response("delete", "Delete")
+        dialog.set_response_appearance(
+            "delete", Adw.ResponseAppearance.DESTRUCTIVE
+        )
+        dialog.set_default_response("cancel")
+        dialog.set_close_response("cancel")
+        dialog.connect("response", self._on_delete_row_response, config)
+        dialog.present()
+
+    def _on_delete_row_response(self, _dialog, response_id: str, config) -> None:
+        if response_id != "delete":
+            return
+
+        if delete_project(config.name):
+            logger.info(f"Deleted project: {config.name}")
+            self.project_list.refresh()
+        else:
+            error = Adw.MessageDialog.new(
+                self,
+                "Could not delete",
+                f"Project '{config.name}' was not found on disk.",
+            )
+            error.add_response("ok", "OK")
+            error.present()
+
+    # ------------------------------------------------------------------
+    # View callbacks
+    # ------------------------------------------------------------------
+
+    def _on_project_activated(self, config: ProjectConfig) -> None:
+        logger.info(f"Project activated: {config.name}")
+        # Hide the main header — SettingsView has its own
+        self.main_header.set_visible(False)
+        self.settings_view.load_config(config)
+        self.stack.set_visible_child_name("settings")
+
+    def _on_settings_saved(self, config: ProjectConfig) -> None:
+        logger.info(f"Settings saved for: {config.name}")
+        # Restore the main header
+        self.main_header.set_visible(True)
+        self.project_list.refresh()
+        self.stack.set_visible_child_name("projects")
+
+    def _on_settings_cancelled(self) -> None:
+        # Restore the main header
+        self.main_header.set_visible(True)
+        self.stack.set_visible_child_name("projects")
+
+    def _on_settings_deleted(self, config: ProjectConfig) -> None:
+        logger.info(f"Settings view deleted: {config.name}")
+        # Restore the main header
+        self.main_header.set_visible(True)
+        self.project_list.refresh()
+        self.stack.set_visible_child_name("projects")
+
+    def _on_analyzer_back(self) -> None:
+        """Called when the Back button in the analyzer is pressed."""
+        # Refresh the project list so last_run updates are visible
+        self.project_list.refresh()
+        # Return to the project list
+        self.main_header.set_visible(True)
+        self.stack.set_visible_child_name("projects")
+        
+    def _on_start_analysis(self, config: ProjectConfig) -> None:
+        """Called when the user clicks Analyze in settings."""
+        logger.info(f"Starting analysis for: {config.name}")
+        self.main_header.set_visible(False)
+        self.analyzer_view.load_config(config)
+        self.stack.set_visible_child_name("analyzer")
+
+    # ------------------------------------------------------------------
+    # Add project
+    # ------------------------------------------------------------------
+
+    def _on_add_clicked(self, _button) -> None:
+        dialog = Gtk.FileDialog.new()
+        dialog.set_title("Select a project directory")
+        dialog.select_folder(self, None, self._on_folder_selected)
+
+    def _on_folder_selected(self, dialog, result) -> None:
+        try:
+            folder = dialog.select_folder_finish(result)
+        except Exception as e:
+            logger.debug(f"Folder selection cancelled or failed: {e}")
+            return
+
+        if folder is None:
+            return
+
+        path = Path(folder.get_path())
+        logger.info(f"Adding project: {path}")
+        self._ask_for_project_name(path)
+
+    def _ask_for_project_name(self, path: Path) -> None:
+        entry = Gtk.Entry()
+        entry.set_text(path.name)
+        entry.set_activates_default(True)
+
+        dialog = Adw.MessageDialog.new(
+            self,
+            "Name this project",
+            f"Directory: {path}",
+        )
+        dialog.set_extra_child(entry)
+        dialog.add_response("cancel", "Cancel")
+        dialog.add_response("add", "Add")
+        dialog.set_response_appearance("add", Adw.ResponseAppearance.SUGGESTED)
+        dialog.set_default_response("add")
+        dialog.set_close_response("cancel")
+
+        dialog.connect("response", self._on_name_response, path, entry)
+        dialog.present()
+
+    def _on_name_response(
+        self,
+        _dialog,
+        response_id: str,
+        path: Path,
+        entry: Gtk.Entry,
+    ) -> None:
+        if response_id != "add":
+            return
+
+        name = entry.get_text().strip()
+        if not name:
+            name = path.name
+
+        config = ProjectConfig(name=name, path=path)
+
+        try:
+            save_project(config)
+            logger.info(f"Saved project: {name}")
+        except Exception as e:
+            logger.error(f"Failed to save project: {e}")
+            error = Adw.MessageDialog.new(
+                self,
+                "Could not save project",
+                str(e),
+            )
+            error.add_response("ok", "OK")
+            error.present()
+            return
+
+        self.project_list.refresh()
+        self.stack.set_visible_child_name("projects")