siftcode 0.3.0__py3-none-any.whl

siftcode/gui/widgets/log_view.py

@@ -0,0 +1,108 @@
+"""
+LogView widget — a scrollable text view for showing log messages.
+
+Provides a simple append(text, level) API and automatic scrolling
+to the bottom on new messages. The log is bounded to MAX_LINES so
+long analyses don't grow it unbounded.
+"""
+
+from __future__ import annotations
+
+from datetime import datetime
+
+import gi
+
+gi.require_version("Gtk", "4.0")
+
+from gi.repository import GLib, Gtk  # noqa: E402
+
+
+class LogView(Gtk.ScrolledWindow):
+    """A scrollable, read-only log display."""
+
+    # Keep the log bounded so long analyses don't grow it forever
+    MAX_LINES = 500
+
+    # CSS class names per log level
+    LEVEL_CLASSES = {
+        "info": "log-info",
+        "success": "log-success",
+        "warning": "log-warning",
+        "error": "log-error",
+    }
+
+    def __init__(self) -> None:
+        super().__init__()
+        self.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC)
+        self.set_vexpand(True)
+        self.set_min_content_height(200)
+
+        self._buffer = Gtk.TextBuffer()
+
+        # Tags for color coding
+        self._buffer.create_tag("info", foreground="#5e5c64")
+        self._buffer.create_tag("success", foreground="#26a269")
+        self._buffer.create_tag("warning", foreground="#e5a50a")
+        self._buffer.create_tag("error", foreground="#c01c28")
+        self._buffer.create_tag("timestamp", foreground="#9a9996")
+
+        self._text_view = Gtk.TextView(buffer=self._buffer)
+        self._text_view.set_editable(False)
+        self._text_view.set_cursor_visible(False)
+        self._text_view.set_monospace(True)
+        self._text_view.set_wrap_mode(Gtk.WrapMode.WORD_CHAR)
+        self._text_view.set_left_margin(12)
+        self._text_view.set_right_margin(12)
+        self._text_view.set_top_margin(8)
+        self._text_view.set_bottom_margin(8)
+
+        self.set_child(self._text_view)
+
+    # ------------------------------------------------------------------
+    # Public API
+    # ------------------------------------------------------------------
+
+    def append(self, text: str, level: str = "info") -> None:
+        """Append a line of text with the given log level."""
+        timestamp = datetime.now().strftime("%H:%M:%S")
+
+        end_iter = self._buffer.get_end_iter()
+
+        # Timestamp
+        self._buffer.insert_with_tags_by_name(
+            end_iter, f"[{timestamp}] ", "timestamp"
+        )
+
+        # Message
+        end_iter = self._buffer.get_end_iter()
+        tag_name = level if level in ("info", "success", "warning", "error") else "info"
+        self._buffer.insert_with_tags_by_name(end_iter, f"{text}\n", tag_name)
+
+        # Trim oldest lines if exceeding MAX_LINES
+        line_count = self._buffer.get_line_count()
+        if line_count > self.MAX_LINES:
+            start = self._buffer.get_start_iter()
+            end = self._buffer.get_iter_at_line(line_count - self.MAX_LINES)
+            self._buffer.delete(start, end)
+
+        # Scroll to bottom
+        self._scroll_to_bottom()
+
+    def clear(self) -> None:
+        """Remove all text from the log."""
+        self._buffer.set_text("")
+
+    # ------------------------------------------------------------------
+    # Internal
+    # ------------------------------------------------------------------
+
+    def _scroll_to_bottom(self) -> None:
+        """Scroll the view to the last line."""
+        # Defer to idle so the layout has time to update
+        GLib.idle_add(self._do_scroll)
+
+    def _do_scroll(self) -> bool:
+        adj = self.get_vadjustment()
+        if adj is not None:
+            adj.set_value(adj.get_upper() - adj.get_page_size())
+        return False  # don't repeat

siftcode/gui/widgets/markdown_view.py

@@ -0,0 +1,205 @@
+"""
+MarkdownView widget — renders a subset of Markdown using Pango
+markup inside a Gtk.TextView. No external dependencies beyond
+PyGObject.
+
+Supported syntax:
+  # H1, ## H2, ### H3, #### H4
+  **bold**, *italic*, `code`
+  - unordered list items
+  1. ordered list items
+  ```fenced code blocks```
+  > blockquotes
+  --- horizontal rules
+  [text](url) — shown as "text (url)"
+"""
+
+from __future__ import annotations
+
+import re
+
+import gi
+
+gi.require_version("Gtk", "4.0")
+
+from gi.repository import Gtk  # noqa: E402
+
+
+class MarkdownView(Gtk.ScrolledWindow):
+    """A scrollable, read-only Markdown renderer based on Pango markup."""
+
+    def __init__(self) -> None:
+        super().__init__()
+        self.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC)
+        self.set_vexpand(True)
+
+        self._buffer = Gtk.TextBuffer()
+
+        # Text tags (Pango-based styling)
+        self._buffer.create_tag(
+            "h1", scale=1.8, weight=700,
+            pixels_above_lines=18, pixels_below_lines=8,
+        )
+        self._buffer.create_tag(
+            "h2", scale=1.5, weight=700,
+            pixels_above_lines=14, pixels_below_lines=6,
+        )
+        self._buffer.create_tag(
+            "h3", scale=1.25, weight=700,
+            pixels_above_lines=10, pixels_below_lines=4,
+        )
+        self._buffer.create_tag(
+            "h4", scale=1.1, weight=700,
+            pixels_above_lines=8, pixels_below_lines=3,
+        )
+        self._buffer.create_tag("bold", weight=700)
+        self._buffer.create_tag("italic", style=2)  # PANGO_STYLE_ITALIC
+        self._buffer.create_tag(
+            "code", family="monospace",
+            background="#f6f5f4", foreground="#a51d2d",
+        )
+        self._buffer.create_tag(
+            "codeblock", family="monospace", background="#f6f5f4",
+            foreground="#1c1c1c",
+            pixels_above_lines=2, pixels_below_lines=2,
+            left_margin=16, right_margin=16,
+        )
+        self._buffer.create_tag("list", left_margin=24)
+        self._buffer.create_tag(
+            "blockquote", style=2, left_margin=24,
+            foreground="#5e5c64",
+        )
+        self._buffer.create_tag(
+            "hr", foreground="#c0bfbc",
+            pixels_above_lines=6, pixels_below_lines=6,
+        )
+        self._buffer.create_tag("paragraph", pixels_below_lines=6)
+
+        self._text_view = Gtk.TextView(buffer=self._buffer)
+        self._text_view.set_editable(False)
+        self._text_view.set_cursor_visible(False)
+        self._text_view.set_wrap_mode(Gtk.WrapMode.WORD_CHAR)
+        self._text_view.set_left_margin(24)
+        self._text_view.set_right_margin(24)
+        self._text_view.set_top_margin(16)
+        self._text_view.set_bottom_margin(16)
+
+        self.set_child(self._text_view)
+
+    # ------------------------------------------------------------------
+    # Public API
+    # ------------------------------------------------------------------
+
+    def load_markdown(self, text: str) -> None:
+        """Render the given Markdown text."""
+        self._buffer.set_text("")
+        self._render(text)
+
+    def load_file(self, path) -> None:
+        """Load and render a Markdown file from disk."""
+        text = path.read_text(encoding="utf-8")
+        self.load_markdown(text)
+
+    # ------------------------------------------------------------------
+    # Rendering
+    # ------------------------------------------------------------------
+
+    def _render(self, text: str) -> None:
+        """Parse Markdown and insert it with Pango tags."""
+        in_code_block = False
+
+        for raw_line in text.split("\n"):
+            line = raw_line.rstrip()
+
+            # Fenced code blocks
+            if line.startswith("```"):
+                in_code_block = not in_code_block
+                if not in_code_block:
+                    # Add a small blank line after the block
+                    self._insert("\n")
+                continue
+
+            if in_code_block:
+                self._insert(line + "\n", "codeblock")
+                continue
+
+            # Headings
+            if line.startswith("#### "):
+                self._insert(line[5:] + "\n", "h4")
+            elif line.startswith("### "):
+                self._insert(line[4:] + "\n", "h3")
+            elif line.startswith("## "):
+                self._insert(line[3:] + "\n", "h2")
+            elif line.startswith("# "):
+                self._insert(line[2:] + "\n", "h1")
+
+            # Horizontal rule
+            elif line.strip() in ("---", "***", "___"):
+                self._insert("─" * 60 + "\n", "hr")
+
+            # Blockquote
+            elif line.startswith("> "):
+                self._insert_inline(line[2:])
+                self._insert("\n", "blockquote")
+
+            # Unordered list
+            elif line.startswith("- ") or line.startswith("* "):
+                self._insert("  •  ", "list")
+                self._insert_inline(line[2:])
+                self._insert("\n", "list")
+
+            # Ordered list
+            elif re.match(r"^\d+\.\s", line):
+                prefix = re.match(r"^(\d+\.)\s", line).group(1)
+                self._insert(f"  {prefix}  ", "list")
+                self._insert_inline(line[len(prefix) + 1:])
+                self._insert("\n", "list")
+
+            # Empty line
+            elif not line:
+                self._insert("\n")
+
+            # Regular paragraph
+            else:
+                self._insert_inline(line)
+                self._insert("\n", "paragraph")
+
+    def _insert(self, text: str, tag: str | None = None) -> None:
+        """Insert text with an optional tag."""
+        end = self._buffer.get_end_iter()
+        if tag:
+            self._buffer.insert_with_tags_by_name(end, text, tag)
+        else:
+            self._buffer.insert(end, text)
+
+    def _insert_inline(self, text: str) -> None:
+        """
+        Insert text handling inline Markdown:
+          **bold**, *italic*, `code`, and [text](url).
+        """
+        pattern = re.compile(
+            r"(\*\*[^*]+\*\*|\*[^*]+\*|`[^`]+`|\[[^\]]+\]\([^)]+\))"
+        )
+        pos = 0
+        for match in pattern.finditer(text):
+            if match.start() > pos:
+                self._insert(text[pos:match.start()])
+
+            token = match.group(0)
+
+            if token.startswith("**") and token.endswith("**"):
+                self._insert(token[2:-2], "bold")
+            elif token.startswith("*") and token.endswith("*"):
+                self._insert(token[1:-1], "italic")
+            elif token.startswith("`") and token.endswith("`"):
+                self._insert(token[1:-1], "code")
+            elif token.startswith("["):
+                m = re.match(r"\[([^\]]+)\]\(([^)]+)\)", token)
+                if m:
+                    self._insert(f"{m.group(1)} ", "bold")
+                    self._insert(f"({m.group(2)})", "italic")
+
+            pos = match.end()
+
+        if pos < len(text):
+            self._insert(text[pos:])

siftcode/gui/widgets/project_row.py

@@ -0,0 +1,141 @@
+"""
+ProjectRow widget — a single row in the project list.
+
+Displays one saved project with its name, path, model, and last-run
+timestamp. Shows a status icon depending on whether the project path
+still exists on disk.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import gi
+
+gi.require_version("Gtk", "4.0")
+gi.require_version("Adw", "1")
+
+from gi.repository import Adw, Gdk, Gio, Gtk  # noqa: E402
+
+from siftcode.core.config import ProjectConfig  # noqa: E402
+
+
+class ProjectRow(Gtk.ListBoxRow):
+    """A single row showing a saved project."""
+
+    def __init__(self, config: ProjectConfig) -> None:
+        super().__init__()
+        self.config = config
+
+        # --- Content layout: icon | text column | meta column ------------
+        box = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL, spacing=12)
+        box.set_margin_top(10)
+        box.set_margin_bottom(10)
+        box.set_margin_start(12)
+        box.set_margin_end(12)
+
+        status_icon = Gtk.Image.new_from_icon_name(
+            "folder-symbolic" if config.path.is_dir()
+            else "dialog-warning-symbolic"
+        )
+        status_icon.set_pixel_size(24)
+        status_icon.set_valign(Gtk.Align.CENTER)
+        if not config.path.is_dir():
+            status_icon.add_css_class("warning")
+        box.append(status_icon)
+
+        text_col = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=2)
+        text_col.set_hexpand(True)
+        text_col.set_valign(Gtk.Align.CENTER)
+
+        name_label = Gtk.Label(label=config.name, xalign=0)
+        name_label.add_css_class("heading")
+        text_col.append(name_label)
+
+        path_label = Gtk.Label(label=_shorten_path(config.path), xalign=0)
+        path_label.add_css_class("dim-label")
+        path_label.add_css_class("caption")
+        text_col.append(path_label)
+
+        box.append(text_col)
+
+        meta_col = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=2)
+        meta_col.set_valign(Gtk.Align.CENTER)
+        meta_col.set_halign(Gtk.Align.END)
+
+        model_label = Gtk.Label(label=config.model.name, xalign=1)
+        model_label.add_css_class("caption")
+        meta_col.append(model_label)
+
+        last_label = Gtk.Label(label=_format_last_run(config.last_run), xalign=1)
+        last_label.add_css_class("dim-label")
+        last_label.add_css_class("caption")
+        meta_col.append(last_label)
+
+        box.append(meta_col)
+
+        self.set_child(box)
+
+        self._setup_context_menu()
+
+    # ------------------------------------------------------------------
+    # Context menu — window-level actions
+    # ------------------------------------------------------------------
+
+    def _setup_context_menu(self) -> None:
+        """
+        Attach a right-click menu.
+
+        The actions reference 'window.edit-row' and 'window.delete-row',
+        which are registered on the MainWindow. This is required because
+        Gtk.PopoverMenu lives in its own popup window and cannot see
+        actions registered on this row's local action group.
+        """
+        menu = Gio.Menu()
+        menu.append("Edit settings", "window.edit-row")
+        menu.append("Open latest guide", "window.open-latest-guide")
+        menu.append("Open output folder", "window.open-output-folder")
+        menu.append("Delete project", "window.delete-row")
+        
+        self._menu = Gtk.PopoverMenu.new_from_model(menu)
+        self._menu.set_parent(self)
+        self._menu.set_has_arrow(False)
+
+        gesture = Gtk.GestureClick.new()
+        gesture.set_button(3)
+        gesture.connect("pressed", self._on_right_click)
+        self.add_controller(gesture)
+
+    def _on_right_click(self, _gesture, _n_press, x, y) -> None:
+        # Register this row as the active row on the window.
+        # The window-level actions will use it when they fire.
+        window = self.get_root()
+        if window is not None and hasattr(window, "_active_row"):
+            window._active_row = self
+
+        rect = Gdk.Rectangle()
+        rect.x = int(x)
+        rect.y = int(y)
+        rect.width = 1
+        rect.height = 1
+        self._menu.set_pointing_to(rect)
+        self._menu.popup()
+
+
+# ---------------------------------------------------------------------------
+# Helpers
+# ---------------------------------------------------------------------------
+
+def _shorten_path(path: Path) -> str:
+    """Replace home directory with ~ for display."""
+    try:
+        return "~/" + str(path.relative_to(Path.home()))
+    except ValueError:
+        return str(path)
+
+
+def _format_last_run(timestamp: str) -> str:
+    """Format an ISO timestamp as a short human-readable string."""
+    if not timestamp:
+        return "never run"
+    return timestamp[:10]