devdash-mac 0.1.0__py3-none-any.whl

devdash/__init__.py

@@ -0,0 +1,4 @@
+"""DevDash - Open-source macOS menubar developer utilities."""
+
+__version__ = "0.1.0"
+__app_name__ = "DevDash"

devdash/__main__.py

@@ -0,0 +1,6 @@
+"""Entry point for `python -m devdash`."""
+
+from devdash.app import main
+
+if __name__ == "__main__":
+    main()

devdash/app.py

@@ -0,0 +1,145 @@
+"""Main DevDash application - macOS menubar app."""
+
+from __future__ import annotations
+
+import rumps
+
+from devdash import __app_name__, __version__, clipboard
+from devdash.config import load_config
+from devdash.plugin_loader import discover_tools
+from devdash.tools.base import DevTool
+from devdash.ui.notifications import notify
+from devdash.ui.windows import show_tool_dialog
+
+# Content type display names for notifications
+_TYPE_NAMES: dict[clipboard.ContentType, str] = {
+    clipboard.ContentType.JSON: "JSON",
+    clipboard.ContentType.JWT: "JWT token",
+    clipboard.ContentType.UUID: "UUID",
+    clipboard.ContentType.BASE64: "Base64",
+    clipboard.ContentType.UNIX_TIMESTAMP: "Unix timestamp",
+    clipboard.ContentType.URL: "URL",
+    clipboard.ContentType.URL_ENCODED: "URL-encoded text",
+    clipboard.ContentType.HEX_COLOR: "HEX color",
+    clipboard.ContentType.CRON: "Cron expression",
+}
+
+
+class DevDashApp(rumps.App):
+    """macOS menubar developer utilities app."""
+
+    def __init__(self) -> None:
+        super().__init__(name=__app_name__, title="\U0001f527", quit_button=None)
+        self._tools: list[DevTool] = discover_tools()
+        self._last_clipboard: str = ""
+        self._build_menu()
+        # Start clipboard watcher if enabled in config
+        config = load_config()
+        if config.get("clipboard_watcher", False):
+            self._start_clipboard_watcher()
+
+    def _build_menu(self) -> None:
+        """Build the menubar dropdown from discovered tools."""
+        menu_items: list[rumps.MenuItem | None] = []
+
+        # Auto-detect clipboard item
+        auto_detect = rumps.MenuItem("Clipboard: Auto-detect", callback=self._on_auto_detect)
+        menu_items.append(auto_detect)
+        menu_items.append(None)  # separator
+
+        # Group tools by category
+        current_category = ""
+        for tool in self._tools:
+            if tool.category != current_category:
+                if current_category:
+                    menu_items.append(None)  # separator between categories
+                current_category = tool.category
+            item = rumps.MenuItem(tool.name, callback=self._make_tool_callback(tool))
+            menu_items.append(item)
+
+        menu_items.append(None)  # separator
+
+        # About and Quit
+        about = rumps.MenuItem(f"About {__app_name__}", callback=self._on_about)
+        quit_item = rumps.MenuItem("Quit", callback=self._on_quit)
+        menu_items.append(about)
+        menu_items.append(quit_item)
+
+        self.menu = menu_items
+
+    def _make_tool_callback(self, tool: DevTool):  # type: ignore[no-untyped-def]
+        """Create a callback closure for a specific tool."""
+
+        def callback(_: rumps.MenuItem) -> None:
+            show_tool_dialog(tool)
+
+        return callback
+
+    def _on_auto_detect(self, _: rumps.MenuItem) -> None:
+        """Read clipboard, detect content type, open matching tool."""
+        content = clipboard.read()
+        if not content.strip():
+            notify("DevDash", "Clipboard is empty")
+            return
+
+        detected = clipboard.detect_type(content)
+        # Find matching tool by keyword
+        keyword_map = {
+            clipboard.ContentType.JSON: "json",
+            clipboard.ContentType.JWT: "jwt",
+            clipboard.ContentType.UUID: "uuid",
+            clipboard.ContentType.BASE64: "base64",
+            clipboard.ContentType.UNIX_TIMESTAMP: "timestamp",
+            clipboard.ContentType.URL: "url",
+            clipboard.ContentType.URL_ENCODED: "url",
+            clipboard.ContentType.HEX_COLOR: "color",
+            clipboard.ContentType.CRON: "cron",
+        }
+        keyword = keyword_map.get(detected)
+        if keyword:
+            for tool in self._tools:
+                if tool.keyword == keyword:
+                    show_tool_dialog(tool, input_text=content)
+                    return
+        notify("DevDash", f"Detected: {detected.name}. No matching tool found.")
+
+    def _on_about(self, _: rumps.MenuItem) -> None:
+        """Show about dialog."""
+        rumps.alert(
+            title=f"About {__app_name__}",
+            message=f"{__app_name__} v{__version__}\n\n"
+            "Open-source macOS menubar developer utilities.\n"
+            "https://github.com/devdash/devdash",
+        )
+
+    def _on_quit(self, _: rumps.MenuItem) -> None:
+        """Quit the app."""
+        rumps.quit_application()
+
+    def _start_clipboard_watcher(self) -> None:
+        """Start background clipboard polling (opt-in, privacy conscious)."""
+
+        @rumps.timer(2)
+        def _watch_clipboard(timer: rumps.Timer) -> None:
+            try:
+                content = clipboard.read()
+                if not content or content == self._last_clipboard:
+                    return
+                self._last_clipboard = content
+                detected = clipboard.detect_type(content)
+                if detected != clipboard.ContentType.PLAIN_TEXT:
+                    type_name = _TYPE_NAMES.get(detected, detected.name)
+                    notify(
+                        "DevDash",
+                        f"Detected {type_name} in your clipboard. Click to process.",
+                    )
+            except Exception:
+                pass  # Never crash the watcher
+
+        _watch_clipboard.start()  # type: ignore[attr-defined]
+
+
+def main() -> None:
+    """Entry point for the application."""
+    app = DevDashApp()
+    app.run()

devdash/clipboard.py

@@ -0,0 +1,98 @@
+"""Clipboard utilities with content type auto-detection."""
+
+import json
+import re
+from enum import Enum, auto
+
+import pyperclip
+
+
+class ContentType(Enum):
+    """Detected content types for clipboard auto-detection."""
+
+    JWT = auto()
+    JSON = auto()
+    UUID = auto()
+    CRON = auto()
+    URL_ENCODED = auto()
+    BASE64 = auto()
+    UNIX_TIMESTAMP = auto()
+    HEX_COLOR = auto()
+    URL = auto()
+    PLAIN_TEXT = auto()
+
+
+_UUID_RE = re.compile(
+    r"^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$", re.IGNORECASE
+)
+_CRON_FIELD = r"[\d*,/\-LW#?]+"
+_CRON_RE = re.compile(rf"^{_CRON_FIELD}(\s+{_CRON_FIELD}){{4,5}}$")
+_URL_ENCODED_RE = re.compile(r"%[0-9A-Fa-f]{2}")
+_BASE64_RE = re.compile(r"^[A-Za-z0-9+/\n\r]+=*$")
+_HEX_COLOR_RE = re.compile(r"^#([0-9A-Fa-f]{3}|[0-9A-Fa-f]{6})$")
+
+
+def read() -> str:
+    """Get current clipboard content as string."""
+    return pyperclip.paste()
+
+
+def write(text: str) -> None:
+    """Write string to clipboard."""
+    pyperclip.copy(text)
+
+
+def detect_type(text: str) -> ContentType:
+    """Auto-detect content type with priority-based detection."""
+    if not text or not text.strip():
+        return ContentType.PLAIN_TEXT
+
+    stripped = text.strip()
+
+    # 1. JWT: starts with "eyJ" and has exactly 2 dots
+    if stripped.startswith("eyJ") and stripped.count(".") == 2:
+        return ContentType.JWT
+
+    # 2. JSON: starts with { or [ and is valid JSON
+    if stripped.startswith(("{", "[")):
+        try:
+            json.loads(stripped)
+            return ContentType.JSON
+        except (json.JSONDecodeError, ValueError):
+            pass
+
+    # 3. UUID: matches 8-4-4-4-12 hex pattern
+    if _UUID_RE.match(stripped):
+        return ContentType.UUID
+
+    # 4. Cron: 5-6 space-separated fields
+    if _CRON_RE.match(stripped):
+        return ContentType.CRON
+
+    # 5. URL-encoded: contains %XX patterns
+    if _URL_ENCODED_RE.search(stripped) and " " not in stripped:
+        return ContentType.URL_ENCODED
+
+    # 6. Base64: matches charset and length multiple of 4
+    if len(stripped) >= 4 and len(stripped) % 4 == 0 and _BASE64_RE.match(stripped):
+        return ContentType.BASE64
+
+    # 7. Unix timestamp: pure digits, 10 or 13 chars, reasonable range
+    if stripped.isdigit() and len(stripped) in (10, 13):
+        ts = int(stripped)
+        if len(stripped) == 13:
+            ts = ts // 1000
+        # Reasonable range: 1970 to 2100
+        if 0 <= ts <= 4102444800:
+            return ContentType.UNIX_TIMESTAMP
+
+    # 8. HEX color: starts with # + 3 or 6 hex chars
+    if _HEX_COLOR_RE.match(stripped):
+        return ContentType.HEX_COLOR
+
+    # 9. URL: starts with http:// or https://
+    if stripped.startswith(("http://", "https://")):
+        return ContentType.URL
+
+    # 10. Fallback
+    return ContentType.PLAIN_TEXT

devdash/config.py

@@ -0,0 +1,51 @@
+"""User preferences management with YAML config."""
+
+import os
+import threading
+from pathlib import Path
+from typing import Any
+
+import yaml
+
+CONFIG_DIR = Path.home() / ".config" / "devdash"
+CONFIG_FILE = CONFIG_DIR / "config.yaml"
+
+_lock = threading.Lock()
+
+DEFAULT_CONFIG: dict[str, Any] = {
+    "default_hash_algorithm": "sha256",
+    "timestamp_format": "%Y-%m-%d %H:%M:%S",
+    "password_length": 16,
+    "uuid_version": "v4",
+    "auto_clipboard_detection": True,
+    "clipboard_watcher": False,
+}
+
+
+def _ensure_config_dir() -> None:
+    """Create config directory if it doesn't exist."""
+    CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+
+
+def load_config() -> dict[str, Any]:
+    """Load config from file, creating defaults on first run."""
+    with _lock:
+        if not CONFIG_FILE.exists():
+            save_config(DEFAULT_CONFIG)
+            return dict(DEFAULT_CONFIG)
+        with open(CONFIG_FILE) as f:
+            data = yaml.safe_load(f)
+        if not isinstance(data, dict):
+            return dict(DEFAULT_CONFIG)
+        # Merge with defaults for any missing keys
+        merged = dict(DEFAULT_CONFIG)
+        merged.update(data)
+        return merged
+
+
+def save_config(config: dict[str, Any]) -> None:
+    """Save config to file with restricted permissions."""
+    _ensure_config_dir()
+    with open(CONFIG_FILE, "w") as f:
+        yaml.dump(config, f, default_flow_style=False)
+    os.chmod(CONFIG_FILE, 0o600)

devdash/plugin_loader.py

@@ -0,0 +1,43 @@
+"""Dynamic tool discovery and registration."""
+
+import importlib
+import logging
+import pkgutil
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from devdash.tools.base import DevTool
+
+logger = logging.getLogger(__name__)
+
+
+def discover_tools() -> list["DevTool"]:
+    """Scan the tools/ directory and return registered tool instances."""
+    tools: list[DevTool] = []
+    package_name = "devdash.tools"
+
+    try:
+        package = importlib.import_module(package_name)
+    except ImportError:
+        logger.error("Could not import tools package")
+        return tools
+
+    package_path = getattr(package, "__path__", None)
+    if package_path is None:
+        return tools
+
+    for _importer, module_name, _ispkg in pkgutil.iter_modules(package_path):
+        if module_name.startswith("_") or module_name == "base":
+            continue
+        try:
+            module = importlib.import_module(f"{package_name}.{module_name}")
+            register_fn = getattr(module, "register", None)
+            if register_fn and callable(register_fn):
+                tool = register_fn()
+                tools.append(tool)
+        except Exception:
+            logger.exception("Failed to load tool module: %s", module_name)
+
+    # Sort by category then name
+    tools.sort(key=lambda t: (t.category, t.name))
+    return tools

devdash/storage.py

@@ -0,0 +1,244 @@
+"""Optional SQLite storage for tool history and favorites.
+
+The database is created lazily on first access and stored at
+~/.config/devdash/history.db with restricted (0o600) permissions.
+All public methods are thread-safe — each call opens its own
+connection so there is no shared state between threads.
+"""
+
+import os
+import sqlite3
+import threading
+from pathlib import Path
+
+from devdash.config import CONFIG_DIR
+
+DB_PATH: Path = CONFIG_DIR / "history.db"
+_PREVIEW_MAX = 200
+_HISTORY_KEEP = 100
+
+_init_lock = threading.Lock()
+_initialized = False
+
+
+def _truncate(text: str | None, limit: int = _PREVIEW_MAX) -> str | None:
+    """Truncate *text* to *limit* characters, appending an ellipsis if cut."""
+    if text is None:
+        return None
+    if len(text) <= limit:
+        return text
+    return text[: limit - 1] + "\u2026"
+
+
+def _ensure_db() -> None:
+    """Create the database file and tables if they do not yet exist.
+
+    Uses a module-level lock so the schema is applied at most once per
+    process, regardless of how many threads call in concurrently.
+    """
+    global _initialized
+    if _initialized:
+        return
+
+    with _init_lock:
+        # Double-check after acquiring the lock.
+        if _initialized:
+            return
+
+        CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+        con = sqlite3.connect(str(DB_PATH))
+        try:
+            con.executescript(
+                """\
+                CREATE TABLE IF NOT EXISTS tool_history (
+                    id              INTEGER PRIMARY KEY AUTOINCREMENT,
+                    tool_name       TEXT    NOT NULL,
+                    input_preview   TEXT,
+                    output_preview  TEXT,
+                    timestamp       TEXT    DEFAULT CURRENT_TIMESTAMP
+                );
+
+                CREATE INDEX IF NOT EXISTS idx_tool_history_tool
+                    ON tool_history (tool_name, timestamp DESC);
+
+                CREATE TABLE IF NOT EXISTS favorites (
+                    id        INTEGER PRIMARY KEY AUTOINCREMENT,
+                    tool_name TEXT NOT NULL,
+                    label     TEXT NOT NULL,
+                    content   TEXT NOT NULL
+                );
+
+                CREATE INDEX IF NOT EXISTS idx_favorites_tool
+                    ON favorites (tool_name);
+                """
+            )
+        finally:
+            con.close()
+
+        os.chmod(DB_PATH, 0o600)
+        _initialized = True
+
+
+def _connect() -> sqlite3.Connection:
+    """Return a new connection to the history database.
+
+    Ensures the schema exists before handing back the connection.
+    """
+    _ensure_db()
+    con = sqlite3.connect(str(DB_PATH))
+    con.row_factory = sqlite3.Row
+    return con
+
+
+class HistoryStore:
+    """High-level interface to the DevDash history / favorites database.
+
+    Supports use as a context manager::
+
+        with HistoryStore() as store:
+            store.add_history("base64", "hello", "aGVsbG8=")
+
+    When used without a context manager, call :meth:`close` explicitly
+    or simply let the garbage collector handle it — each public method
+    opens (and closes) its own connection, so the instance itself holds
+    no long-lived resources.
+    """
+
+    def __init__(self) -> None:
+        self._closed = False
+
+    # -- context manager ----------------------------------------------------
+
+    def __enter__(self) -> "HistoryStore":
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb) -> None:  # noqa: ANN001
+        self.close()
+        return None
+
+    def close(self) -> None:
+        """Mark the store as closed.  Subsequent calls will raise."""
+        self._closed = True
+
+    def _check_open(self) -> None:
+        if self._closed:
+            raise RuntimeError("HistoryStore is closed")
+
+    # -- tool_history -------------------------------------------------------
+
+    def add_history(
+        self,
+        tool_name: str,
+        input_text: str | None = None,
+        output_text: str | None = None,
+    ) -> None:
+        """Record a tool invocation, then auto-cleanup old rows."""
+        self._check_open()
+        in_prev = _truncate(input_text)
+        out_prev = _truncate(output_text)
+        con = _connect()
+        try:
+            con.execute(
+                "INSERT INTO tool_history (tool_name, input_preview, output_preview) "
+                "VALUES (?, ?, ?)",
+                (tool_name, in_prev, out_prev),
+            )
+            con.commit()
+        finally:
+            con.close()
+        self.cleanup(tool_name)
+
+    def get_history(self, tool_name: str, limit: int = 20) -> list[dict]:
+        """Return the most recent *limit* history rows for *tool_name*."""
+        self._check_open()
+        con = _connect()
+        try:
+            rows = con.execute(
+                "SELECT id, tool_name, input_preview, output_preview, timestamp "
+                "FROM tool_history "
+                "WHERE tool_name = ? "
+                "ORDER BY timestamp DESC "
+                "LIMIT ?",
+                (tool_name, limit),
+            ).fetchall()
+            return [dict(r) for r in rows]
+        finally:
+            con.close()
+
+    # -- favorites ----------------------------------------------------------
+
+    def add_favorite(self, tool_name: str, label: str, content: str) -> int:
+        """Save a favorite and return its row id."""
+        self._check_open()
+        con = _connect()
+        try:
+            cur = con.execute(
+                "INSERT INTO favorites (tool_name, label, content) VALUES (?, ?, ?)",
+                (tool_name, label, content),
+            )
+            con.commit()
+            return cur.lastrowid  # type: ignore[return-value]
+        finally:
+            con.close()
+
+    def get_favorites(self, tool_name: str) -> list[dict]:
+        """Return all favorites for *tool_name*, ordered by id."""
+        self._check_open()
+        con = _connect()
+        try:
+            rows = con.execute(
+                "SELECT id, tool_name, label, content "
+                "FROM favorites "
+                "WHERE tool_name = ? "
+                "ORDER BY id",
+                (tool_name,),
+            ).fetchall()
+            return [dict(r) for r in rows]
+        finally:
+            con.close()
+
+    def remove_favorite(self, favorite_id: int) -> bool:
+        """Delete a favorite by id.  Returns True if a row was deleted."""
+        self._check_open()
+        con = _connect()
+        try:
+            cur = con.execute("DELETE FROM favorites WHERE id = ?", (favorite_id,))
+            con.commit()
+            return cur.rowcount > 0
+        finally:
+            con.close()
+
+    # -- maintenance --------------------------------------------------------
+
+    def cleanup(self, tool_name: str | None = None) -> None:
+        """Trim tool_history to the newest *_HISTORY_KEEP* rows per tool.
+
+        If *tool_name* is given, only that tool is cleaned.  Otherwise
+        every tool present in the table is processed.
+        """
+        self._check_open()
+        con = _connect()
+        try:
+            if tool_name is not None:
+                tools = [tool_name]
+            else:
+                tools = [
+                    row["tool_name"]
+                    for row in con.execute("SELECT DISTINCT tool_name FROM tool_history").fetchall()
+                ]
+
+            for name in tools:
+                con.execute(
+                    "DELETE FROM tool_history "
+                    "WHERE tool_name = ? "
+                    "AND id NOT IN ("
+                    "  SELECT id FROM tool_history "
+                    "  WHERE tool_name = ? "
+                    "  ORDER BY timestamp DESC "
+                    "  LIMIT ?"
+                    ")",
+                    (name, name, _HISTORY_KEEP),
+                )
+            con.commit()
+        finally:
+            con.close()

devdash/tools/__init__.py

@@ -0,0 +1 @@
+"""DevDash tools registry."""

devdash/tools/base.py

@@ -0,0 +1,38 @@
+"""Abstract base class for all DevDash tools."""
+
+from abc import ABC, abstractmethod
+
+
+class DevTool(ABC):
+    """Base class for all DevDash tools."""
+
+    @property
+    @abstractmethod
+    def name(self) -> str:
+        """Display name in the menu."""
+        ...
+
+    @property
+    @abstractmethod
+    def keyword(self) -> str:
+        """Short identifier for CLI and auto-detection."""
+        ...
+
+    @property
+    def category(self) -> str:
+        """Menu category grouping."""
+        return "General"
+
+    @property
+    def description(self) -> str:
+        """One-line description shown in tooltip."""
+        return ""
+
+    @abstractmethod
+    def process(self, input_text: str, **kwargs: object) -> str:
+        """Process input and return output string."""
+        ...
+
+    def validate(self, input_text: str) -> str | None:
+        """Validate input. Return error message or None if valid."""
+        return None