siftcode 0.3.0__py3-none-any.whl

siftcode/gui/settings_view.py

@@ -0,0 +1,430 @@
+"""
+Settings view — edit a project's configuration.
+
+Phase 3: basic fields, model settings, analysis settings.
+Phase 4: Analyze button hands off to the analyzer view.
+"""
+
+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
+    ProjectConfig,
+    delete_project,
+    save_project,
+)
+from siftcode.gui.widgets.exclusion_list import ExclusionList  # noqa: E402
+
+
+logger = logging.getLogger(__name__)
+
+
+class SettingsView(Adw.Bin):
+    """
+    A view for editing one project's configuration.
+
+    Callbacks:
+        set_on_saved(cb)     — cb(config) after Save writes to disk
+        set_on_cancelled(cb) — cb() when Cancel is clicked
+        set_on_deleted(cb)   — cb(config) after Delete succeeds
+        set_on_analyze(cb)   — cb(config) after Analyze is clicked
+                               (settings are saved before this fires)
+    """
+
+    def __init__(self) -> None:
+        super().__init__()
+
+        self._config: ProjectConfig | None = None
+        self._on_saved = None
+        self._on_cancelled = None
+        self._on_deleted = None
+        self._on_analyze = None
+
+        # Root layout
+        self._toolbar_view = Adw.ToolbarView()
+
+        # Header bar with title + Cancel / Delete / Save / Analyze
+        self._header = Adw.HeaderBar()
+        self._title = Adw.WindowTitle(title="Settings", subtitle="")
+        self._header.set_title_widget(self._title)
+
+        self._cancel_button = Gtk.Button(label="Cancel")
+        self._cancel_button.connect("clicked", self._on_cancel_clicked)
+        self._header.pack_start(self._cancel_button)
+
+        # Analyze button — primary action (rightmost)
+        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)
+
+        # Save button
+        self._save_button = Gtk.Button(label="Save")
+        self._save_button.connect("clicked", self._on_save_clicked)
+        self._header.pack_end(self._save_button)
+
+        # Delete button (destructive action)
+        self._delete_button = Gtk.Button.new_from_icon_name("user-trash-symbolic")
+        self._delete_button.add_css_class("destructive-action")
+        self._delete_button.set_tooltip_text("Delete this project")
+        self._delete_button.connect("clicked", self._on_delete_clicked)
+        self._header.pack_end(self._delete_button)
+
+        self._toolbar_view.add_top_bar(self._header)
+
+        # Content
+        self._content_box = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=24)
+        self._content_box.set_margin_top(24)
+        self._content_box.set_margin_bottom(24)
+        self._content_box.set_margin_start(24)
+        self._content_box.set_margin_end(24)
+
+        scrolled = Gtk.ScrolledWindow()
+        scrolled.set_vexpand(True)
+        scrolled.set_child(self._content_box)
+        self._toolbar_view.set_content(scrolled)
+
+        self.set_child(self._toolbar_view)
+
+    # ------------------------------------------------------------------
+    # Public API
+    # ------------------------------------------------------------------
+
+    def set_on_saved(self, callback) -> None:
+        self._on_saved = callback
+
+    def set_on_cancelled(self, callback) -> None:
+        self._on_cancelled = callback
+
+    def set_on_deleted(self, callback) -> None:
+        self._on_deleted = callback
+
+    def set_on_analyze(self, callback) -> None:
+        """Set a callback invoked when Analyze is clicked. Receives the config."""
+        self._on_analyze = callback
+
+    def load_config(self, config: ProjectConfig) -> None:
+        """Populate the view from a ProjectConfig (deep-copied)."""
+        self._config = ProjectConfig.from_dict(config.to_dict())
+
+        # Clear existing content
+        while (child := self._content_box.get_first_child()) is not None:
+            self._content_box.remove(child)
+
+        self._title.set_title(self._config.name or "Untitled")
+        self._title.set_subtitle(str(self._config.path))
+
+        self._content_box.append(self._build_identity_group())
+        self._content_box.append(self._build_model_group())
+        self._content_box.append(self._build_analysis_group())
+
+    # ------------------------------------------------------------------
+    # UI Groups
+    # ------------------------------------------------------------------
+
+    def _build_identity_group(self) -> Adw.PreferencesGroup:
+        group = Adw.PreferencesGroup()
+        group.set_title("Identity")
+
+        # Name
+        self._name_row = Adw.EntryRow()
+        self._name_row.set_title("Project name")
+        self._name_row.set_text(self._config.name)
+        self._name_row.connect("changed", self._on_name_changed)
+        group.add(self._name_row)
+
+        # Path (clickable — opens a folder picker)
+        self._path_row = Adw.ActionRow()
+        self._path_row.set_title("Path")
+        self._path_row.set_subtitle(str(self._config.path))
+        self._path_row.set_activatable(True)
+        self._path_row.connect("activated", self._on_change_path_clicked)
+
+        # "Change folder" button on the right
+        change_button = Gtk.Button.new_from_icon_name("document-open-symbolic")
+        change_button.set_tooltip_text("Change project folder")
+        change_button.add_css_class("flat")
+        change_button.set_valign(Gtk.Align.CENTER)
+        change_button.connect("clicked", self._on_change_path_clicked)
+        self._path_row.add_suffix(change_button)
+
+        group.add(self._path_row)
+
+        # Notes
+        notes_row = Adw.ExpanderRow()
+        notes_row.set_title("Notes")
+        notes_row.set_subtitle(self._config.notes or "No notes")
+        self._notes_view = Gtk.TextView()
+        self._notes_view.set_wrap_mode(Gtk.WrapMode.WORD_CHAR)
+        self._notes_view.get_buffer().set_text(self._config.notes or "")
+        self._notes_view.set_margin_top(6)
+        self._notes_view.set_margin_bottom(6)
+        self._notes_view.set_margin_start(6)
+        self._notes_view.set_margin_end(6)
+        notes_row.add_row(self._notes_view)
+        self._notes_row = notes_row
+        group.add(notes_row)
+
+        return group
+
+    def _build_model_group(self) -> Adw.PreferencesGroup:
+        group = Adw.PreferencesGroup()
+        group.set_title("Model")
+        group.set_description("LLM settings used when analyzing this project")
+
+        self._model_row = Adw.EntryRow()
+        self._model_row.set_title("Model name")
+        self._model_row.set_text(self._config.model.name)
+        group.add(self._model_row)
+
+        self._url_row = Adw.EntryRow()
+        self._url_row.set_title("Ollama URL")
+        self._url_row.set_text(self._config.model.ollama_url)
+        group.add(self._url_row)
+
+        self._num_ctx_row = Adw.SpinRow.new_with_range(512, 131072, 512)
+        self._num_ctx_row.set_title("Context length")
+        self._num_ctx_row.set_subtitle("Tokens per request (larger = more VRAM)")
+        self._num_ctx_row.set_value(self._config.model.num_ctx)
+        group.add(self._num_ctx_row)
+
+        self._temp_row = Adw.SpinRow.new_with_range(0.0, 2.0, 0.1)
+        self._temp_row.set_title("Temperature")
+        self._temp_row.set_subtitle("0 = deterministic, 2 = creative")
+        self._temp_row.set_digits(1)
+        self._temp_row.set_value(self._config.model.temperature)
+        group.add(self._temp_row)
+
+        self._timeout_row = Adw.SpinRow.new_with_range(30, 3600, 30)
+        self._timeout_row.set_title("Timeout")
+        self._timeout_row.set_subtitle("Seconds per LLM request")
+        self._timeout_row.set_value(self._config.model.timeout)
+        group.add(self._timeout_row)
+
+        return group
+
+    def _build_analysis_group(self) -> Adw.PreferencesGroup:
+        group = Adw.PreferencesGroup()
+        group.set_title("Analysis")
+        group.set_description("What gets analyzed and how")
+
+        self._cache_row = Adw.SwitchRow()
+        self._cache_row.set_title("Use cache")
+        self._cache_row.set_subtitle(
+            "Skip unchanged files when re-analyzing this project"
+        )
+        self._cache_row.set_active(self._config.analysis.use_cache)
+        group.add(self._cache_row)
+
+        self._max_chars_row = Adw.SpinRow.new_with_range(1000, 200000, 1000)
+        self._max_chars_row.set_title("File size limit")
+        self._max_chars_row.set_subtitle(
+            "Maximum characters per file (larger files are truncated)"
+        )
+        self._max_chars_row.set_value(self._config.analysis.max_file_chars)
+        group.add(self._max_chars_row)
+
+        exclusions_row = Adw.ExpanderRow()
+        exclusions_row.set_title("Excluded files and patterns")
+        exclusions_row.set_subtitle(
+            f"{len(self._config.analysis.exclude)} pattern(s)"
+        )
+
+        self._exclusion_list = ExclusionList()
+        self._exclusion_list.set_patterns(self._config.analysis.exclude)
+        self._exclusion_list.set_on_changed(self._on_exclusions_changed)
+        self._exclusion_list.set_margin_top(6)
+        self._exclusion_list.set_margin_bottom(6)
+        self._exclusion_list.set_margin_start(6)
+        self._exclusion_list.set_margin_end(6)
+
+        exclusions_row.add_row(self._exclusion_list)
+        self._exclusions_row = exclusions_row
+        group.add(exclusions_row)
+
+        return group
+
+    # ------------------------------------------------------------------
+    # Signals
+    # ------------------------------------------------------------------
+
+    def _on_name_changed(self, row: Adw.EntryRow) -> None:
+        self._title.set_title(row.get_text() or "Untitled")
+
+    def _on_exclusions_changed(self, patterns: list[str]) -> None:
+        if hasattr(self, "_exclusions_row"):
+            self._exclusions_row.set_subtitle(f"{len(patterns)} pattern(s)")
+
+    # ------------------------------------------------------------------
+    # Path change (folder picker)
+    # ------------------------------------------------------------------
+
+    def _on_change_path_clicked(self, _widget) -> None:
+        """Open a folder picker to change the project path."""
+        if self._config is None:
+            return
+
+        dialog = Gtk.FileDialog.new()
+        dialog.set_title("Select project folder")
+        try:
+            dialog.set_initial_folder(
+                Gio.File.new_for_path(str(self._config.path))
+            )
+        except Exception:
+            # Path might not exist anymore; skip initial folder
+            pass
+
+        dialog.select_folder(
+            self.get_root(), None, self._on_folder_selected
+        )
+
+    def _on_folder_selected(self, dialog, result) -> None:
+        """Callback when the user picks a new folder."""
+        try:
+            folder = dialog.select_folder_finish(result)
+        except Exception as e:
+            logger.debug(f"Folder selection cancelled: {e}")
+            return
+
+        if folder is None:
+            return
+
+        new_path = Path(folder.get_path())
+
+        if new_path == self._config.path:
+            return  # no change
+
+        if not new_path.is_dir():
+            self._show_error(
+                "Invalid folder",
+                f"{new_path} is not a directory.",
+            )
+            return
+
+        # Update in-memory config and the row subtitle
+        self._config.path = new_path
+        self._path_row.set_subtitle(str(new_path))
+        logger.info(f"Project path changed to: {new_path}")
+
+    def _show_error(self, title: str, message: str) -> None:
+        """Show a simple error dialog."""
+        dialog = Adw.MessageDialog.new(
+            self.get_root(),
+            title,
+            message,
+        )
+        dialog.add_response("ok", "OK")
+        dialog.present()
+
+    # ------------------------------------------------------------------
+    # Save / Cancel / Analyze / Delete
+    # ------------------------------------------------------------------
+
+    def _collect_config_from_widgets(self) -> None:
+        """Read all widget values back into self._config."""
+        self._config.name = self._name_row.get_text().strip() or "Untitled"
+
+        buffer = self._notes_view.get_buffer()
+        start = buffer.get_start_iter()
+        end = buffer.get_end_iter()
+        self._config.notes = buffer.get_text(start, end, False).strip()
+
+        # Model settings
+        self._config.model.name = self._model_row.get_text().strip()
+        self._config.model.ollama_url = self._url_row.get_text().strip()
+        self._config.model.num_ctx = int(self._num_ctx_row.get_value())
+        self._config.model.temperature = float(self._temp_row.get_value())
+        self._config.model.timeout = int(self._timeout_row.get_value())
+
+        # Analysis settings
+        self._config.analysis.use_cache = self._cache_row.get_active()
+        self._config.analysis.max_file_chars = int(self._max_chars_row.get_value())
+        self._config.analysis.exclude = self._exclusion_list.get_patterns()
+
+        # Note: path is NOT read from a widget — it's stored in _config
+        # and updated by the folder picker.
+
+    def _try_save(self) -> bool:
+        """Collect, validate and persist. Returns True on success."""
+        if self._config is None:
+            return False
+
+        self._collect_config_from_widgets()
+
+        try:
+            self._config.validate()
+        except ValueError as e:
+            self._show_error("Invalid settings", str(e))
+            return False
+
+        try:
+            save_project(self._config)
+            logger.info(f"Saved settings for '{self._config.name}'")
+        except Exception as e:
+            logger.error(f"Failed to save settings: {e}")
+            self._show_error("Could not save", str(e))
+            return False
+
+        return True
+
+    def _on_save_clicked(self, _button) -> None:
+        if not self._try_save():
+            return
+        if self._on_saved:
+            self._on_saved(self._config)
+
+    def _on_analyze_clicked(self, _button) -> None:
+        """Save current settings, then hand off to the analyzer view."""
+        if not self._try_save():
+            return
+        if self._on_saved:
+            self._on_saved(self._config)
+        if self._on_analyze:
+            self._on_analyze(self._config)
+
+    def _on_cancel_clicked(self, _button) -> None:
+        if self._on_cancelled:
+            self._on_cancelled()
+
+    def _on_delete_clicked(self, _button) -> None:
+        if self._config is None:
+            return
+
+        dialog = Adw.MessageDialog.new(
+            self.get_root(),
+            "Delete project?",
+            f"Are you sure you want to delete '{self._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_response)
+        dialog.present()
+
+    def _on_delete_response(self, _dialog, response_id: str) -> None:
+        if response_id != "delete" or self._config is None:
+            return
+
+        if delete_project(self._config.name):
+            logger.info(f"Deleted project: {self._config.name}")
+            if self._on_deleted:
+                self._on_deleted(self._config)
+        else:
+            self._show_error(
+                "Could not delete",
+                f"Project '{self._config.name}' was not found on disk.",
+            )

siftcode/gui/widgets/__init__.py

@@ -0,0 +1 @@
+"""Reusable GTK widgets for Siftcode."""

siftcode/gui/widgets/exclusion_list.py

@@ -0,0 +1,169 @@
+"""
+ExclusionList widget — a tag-based editor for excluded file patterns.
+
+Displays the current exclusions as removable tags, with an entry
+field at the bottom for adding new ones.
+"""
+
+from __future__ import annotations
+
+import gi
+
+gi.require_version("Gtk", "4.0")
+gi.require_version("Adw", "1")
+
+from gi.repository import Adw, Gtk  # noqa: E402
+
+from siftcode.core.config import DEFAULT_EXCLUSIONS  # noqa: E402
+
+
+class ExclusionList(Gtk.Box):
+    """
+    A vertical box with:
+      - a FlowBox of removable tags
+      - an entry field for adding new patterns
+      - a "Reset to defaults" button
+    """
+
+    def __init__(self) -> None:
+        super().__init__(orientation=Gtk.Orientation.VERTICAL, spacing=8)
+
+        self._patterns: list[str] = []
+        self._on_changed = None
+
+        # Tag container (rebuilt on every change)
+        self._flow = Gtk.FlowBox()
+        self._flow.set_selection_mode(Gtk.SelectionMode.NONE)
+        self._flow.set_max_children_per_line(20)
+        self._flow.set_min_children_per_line(1)
+        self._flow.set_row_spacing(4)
+        self._flow.set_column_spacing(4)
+        self._flow.set_margin_top(6)
+        self._flow.set_margin_bottom(6)
+        self._flow.set_margin_start(6)
+        self._flow.set_margin_end(6)
+        self.append(self._flow)
+
+        # Empty-state label (shown when no patterns)
+        self._empty_label = Gtk.Label(
+            label="No exclusions — all files will be analyzed",
+            xalign=0,
+        )
+        self._empty_label.add_css_class("dim-label")
+        self._empty_label.add_css_class("caption")
+        self._empty_label.set_margin_start(6)
+        self.append(self._empty_label)
+
+        # Entry for adding new patterns
+        entry_box = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL, spacing=6)
+        entry_box.set_margin_start(6)
+        entry_box.set_margin_end(6)
+        entry_box.set_margin_bottom(6)
+
+        self._entry = Gtk.Entry()
+        self._entry.set_placeholder_text("Add pattern (e.g. tests, .log)")
+        self._entry.set_hexpand(True)
+        self._entry.connect("activate", self._on_entry_activated)
+        entry_box.append(self._entry)
+
+        add_button = Gtk.Button(label="Add")
+        add_button.connect("clicked", lambda *_: self._on_entry_activated(self._entry))
+        entry_box.append(add_button)
+
+        self.append(entry_box)
+
+        # Reset button
+        reset_button = Gtk.Button(label="Reset to defaults")
+        reset_button.add_css_class("flat")
+        reset_button.set_halign(Gtk.Align.START)
+        reset_button.set_margin_start(6)
+        reset_button.set_margin_bottom(6)
+        reset_button.connect("clicked", self._on_reset_clicked)
+        self.append(reset_button)
+
+    # ------------------------------------------------------------------
+    # Public API
+    # ------------------------------------------------------------------
+
+    def set_patterns(self, patterns: list[str]) -> None:
+        """Replace the current list of patterns."""
+        self._patterns = list(patterns)
+        self._rebuild_tags()
+        self._notify_changed()
+
+    def get_patterns(self) -> list[str]:
+        """Return the current patterns as a new list."""
+        return list(self._patterns)
+
+    def set_on_changed(self, callback) -> None:
+        """Set a callback invoked when patterns change."""
+        self._on_changed = callback
+
+    # ------------------------------------------------------------------
+    # Internal
+    # ------------------------------------------------------------------
+
+    def _rebuild_tags(self) -> None:
+        """Remove all tags and rebuild them from self._patterns."""
+        # Clear existing tags
+        while (child := self._flow.get_first_child()) is not None:
+            self._flow.remove(child)
+
+        # Toggle empty label
+        self._empty_label.set_visible(not self._patterns)
+
+        # Add a tag for each pattern
+        for pattern in self._patterns:
+            self._flow.append(self._make_tag(pattern))
+
+    def _make_tag(self, pattern: str) -> Gtk.Widget:
+        """Build a single removable tag."""
+        box = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL, spacing=4)
+        box.add_css_class("pill")
+        box.set_margin_top(2)
+        box.set_margin_bottom(2)
+
+        label = Gtk.Label(label=pattern)
+        label.set_margin_start(8)
+        label.set_margin_end(2)
+        box.append(label)
+
+        remove_button = Gtk.Button.new_from_icon_name("window-close-symbolic")
+        remove_button.add_css_class("flat")
+        remove_button.add_css_class("circular")
+        remove_button.set_tooltip_text(f"Remove '{pattern}'")
+        remove_button.connect("clicked", lambda *_: self._remove_pattern(pattern))
+        box.append(remove_button)
+
+        return box
+
+    def _add_pattern(self, pattern: str) -> None:
+        pattern = pattern.strip()
+        if not pattern or pattern in self._patterns:
+            return
+        self._patterns.append(pattern)
+        self._rebuild_tags()
+        self._notify_changed()
+
+    def _remove_pattern(self, pattern: str) -> None:
+        if pattern in self._patterns:
+            self._patterns.remove(pattern)
+            self._rebuild_tags()
+            self._notify_changed()
+
+    def _notify_changed(self) -> None:
+        if self._on_changed:
+            self._on_changed(self.get_patterns())
+
+    # ------------------------------------------------------------------
+    # Signals
+    # ------------------------------------------------------------------
+
+    def _on_entry_activated(self, entry: Gtk.Entry) -> None:
+        text = entry.get_text()
+        if text.strip():
+            self._add_pattern(text)
+            entry.set_text("")
+
+    def _on_reset_clicked(self, _button) -> None:
+        self.set_patterns(list(DEFAULT_EXCLUSIONS))