dulus 0.2.0__py3-none-any.whl

gui/personas.py

@@ -0,0 +1,230 @@
+"""Persona system for Dulus GUI.
+
+Loads the canonical persona definitions from .dulus-context/personas.json
+and provides helpers for retrieving persona data and rendering cards in
+customtkinter interfaces.
+"""
+from __future__ import annotations
+
+import json
+import os
+from pathlib import Path
+from typing import Any
+
+# ── Paths ───────────────────────────────────────────────────────────────────
+
+_REPO_ROOT = Path(__file__).resolve().parent.parent
+_DEFAULT_JSON_PATH = _REPO_ROOT / ".dulus-context" / "personas.json"
+
+
+# ── Cache ───────────────────────────────────────────────────────────────────
+
+_persona_data: dict[str, Any] | None = None
+
+
+def _load_json(path: Path | str | None = None) -> dict[str, Any]:
+    """Load and cache personas.json. Raises FileNotFoundError if missing."""
+    global _persona_data
+    if _persona_data is not None:
+        return _persona_data
+
+    target = Path(path) if path else _DEFAULT_JSON_PATH
+    with target.open("r", encoding="utf-8") as fh:
+        _persona_data = json.load(fh)
+    return _persona_data
+
+
+def reload() -> dict[str, Any]:
+    """Force reload personas.json from disk and return the raw data."""
+    global _persona_data
+    _persona_data = None
+    return _load_json()
+
+
+# ── Core API ────────────────────────────────────────────────────────────────
+
+def get_all_personas(path: Path | str | None = None) -> list[dict[str, Any]]:
+    """Return all persona definitions as a list of dicts."""
+    data = _load_json(path)
+    return list(data.get("personas", []))
+
+
+def get_persona(persona_id: str, path: Path | str | None = None) -> dict[str, Any] | None:
+    """Return a single persona by its ``id`` (e.g. ``'kevrojo'``)."""
+    for p in get_all_personas(path):
+        if p.get("id") == persona_id:
+            return p
+    return None
+
+
+def get_color_for_agent(agent_name: str, path: Path | str | None = None) -> str:
+    """Return the hex color for an agent name/id (case-insensitive).
+
+    Falls back to the default Dulus accent ``#ff6b1f`` if unknown.
+    """
+    lookup = agent_name.lower().strip()
+    for p in get_all_personas(path):
+        if p.get("id", "").lower() == lookup or p.get("name", "").lower() == lookup:
+            return p.get("color", "#ff6b1f")
+    return "#ff6b1f"
+
+
+def get_display_name(agent_name: str, path: Path | str | None = None) -> str:
+    """Return the pretty display name for an agent, or the raw name as fallback."""
+    lookup = agent_name.lower().strip()
+    for p in get_all_personas(path):
+        if p.get("id", "").lower() == lookup or p.get("name", "").lower() == lookup:
+            return p.get("display_name") or p.get("name") or agent_name
+    return agent_name
+
+
+# ── customtkinter Widget (optional) ─────────────────────────────────────────
+
+try:
+    import customtkinter as ctk
+    _HAS_CTK = True
+except Exception:  # pragma: no cover
+    _HAS_CTK = False
+
+
+class PersonaCard(ctk.CTkFrame if _HAS_CTK else object):  # type: ignore[misc]
+    """A small card widget that displays a single persona's identity.
+
+    Usage::
+
+        card = PersonaCard(parent, persona=get_persona("kimi-code"))
+        card.pack(padx=10, pady=10, fill="both", expand=True)
+    """
+
+    def __init__(
+        self,
+        master: Any,
+        persona: dict[str, Any],
+        width: int = 340,
+        height: int = 280,
+        **kwargs: Any,
+    ) -> None:
+        if not _HAS_CTK:
+            raise RuntimeError("customtkinter is required to use PersonaCard")
+
+        self._persona = persona
+        self._color = persona.get("color", "#ff6b1f")
+        self._accent = persona.get("accent_color", self._color)
+
+        super().__init__(
+            master,
+            width=width,
+            height=height,
+            corner_radius=8,
+            fg_color=("#f9f9f9", "#15151a"),
+            border_width=1,
+            border_color=self._color,
+            **kwargs,
+        )
+
+        self._build()
+
+    def _build(self) -> None:
+        # Top accent bar
+        self._top = ctk.CTkFrame(self, height=3, fg_color=self._color)
+        self._top.pack(fill="x", padx=0, pady=0)
+
+        # Header row: ASCII avatar + meta
+        self._header = ctk.CTkFrame(self, fg_color="transparent")
+        self._header.pack(fill="x", padx=12, pady=(12, 8))
+
+        # Avatar label (monospace)
+        avatar_text = self._persona.get("avatar_ascii", "?")
+        self._avatar = ctk.CTkLabel(
+            self._header,
+            text=avatar_text,
+            font=ctk.CTkFont(family="Consolas", size=9),
+            text_color=self._color,
+            width=120,
+            height=110,
+            fg_color=("#eeeeee", "#0f0f12"),
+            corner_radius=6,
+        )
+        self._avatar.pack(side="left", padx=(0, 12))
+
+        # Meta column
+        self._meta = ctk.CTkFrame(self._header, fg_color="transparent")
+        self._meta.pack(side="left", fill="both", expand=True)
+
+        display = self._persona.get("display_name", self._persona.get("name", "???"))
+        self._name_lbl = ctk.CTkLabel(
+            self._meta,
+            text=display,
+            font=ctk.CTkFont(family="JetBrains Mono", size=16, weight="bold"),
+            text_color=self._color,
+            anchor="w",
+        )
+        self._name_lbl.pack(fill="x")
+
+        role = self._persona.get("role", "Agent")
+        self._role_lbl = ctk.CTkLabel(
+            self._meta,
+            text=role,
+            font=ctk.CTkFont(family="JetBrains Mono", size=10),
+            text_color=self._accent,
+            anchor="w",
+        )
+        self._role_lbl.pack(fill="x", pady=(2, 6))
+
+        ptype = self._persona.get("type", "unknown")
+        self._type_lbl = ctk.CTkLabel(
+            self._meta,
+            text=f"● {ptype}",
+            font=ctk.CTkFont(family="JetBrains Mono", size=10),
+            text_color=("#888888", "#6a6470"),
+            anchor="w",
+        )
+        self._type_lbl.pack(fill="x")
+
+        # Catchphrase
+        catch = self._persona.get("catchphrase", "")
+        if catch:
+            self._catch = ctk.CTkLabel(
+                self,
+                text=f'"{catch}"',
+                font=ctk.CTkFont(family="JetBrains Mono", size=11, slant="italic"),
+                text_color=("#555555", "#8a8490"),
+                anchor="w",
+                wraplength=300,
+            )
+            self._catch.pack(fill="x", padx=12, pady=(0, 8))
+
+        # Skills tags
+        skills = self._persona.get("skills", [])
+        if skills:
+            self._skills_frame = ctk.CTkFrame(self, fg_color="transparent")
+            self._skills_frame.pack(fill="x", padx=12, pady=(0, 8))
+            for skill in skills[:5]:
+                tag = ctk.CTkLabel(
+                    self._skills_frame,
+                    text=skill,
+                    font=ctk.CTkFont(family="JetBrains Mono", size=9),
+                    text_color=self._color,
+                    fg_color=("#eeeeee", "#0a0a0a"),
+                    corner_radius=4,
+                    padx=6,
+                    pady=2,
+                )
+                tag.pack(side="left", padx=(0, 4), pady=(0, 4))
+
+
+# ── Quick smoke-test ────────────────────────────────────────────────────────
+if __name__ == "__main__":
+    import pprint
+
+    print("=== All personas ===")
+    pprint.pprint(get_all_personas())
+
+    print("\n=== Get persona 'kevrojo' ===")
+    pprint.pprint(get_persona("kevrojo"))
+
+    print("\n=== Color for 'kimi-code2' ===")
+    print(get_color_for_agent("kimi-code2"))
+
+    print("\n=== Display name for 'dulus' ===")
+    print(get_display_name("dulus"))

gui/session_utils.py

@@ -0,0 +1,189 @@
+"""Utility functions for managing Dulus GUI sessions."""
+import json
+import datetime
+import uuid
+from pathlib import Path
+from config import SESSIONS_DIR, DAILY_DIR, MR_SESSION_DIR, SESSION_HIST_FILE
+
+def build_title(messages: list[dict]) -> str:
+    """Generate a descriptive title from the first user message."""
+    for m in messages:
+        if m.get("role") == "user":
+            content = m.get("content", "")
+            if isinstance(content, list):
+                # Handle multi-modal or list content
+                text = " ".join(part.get("text", "") for part in content if isinstance(part, dict))
+            else:
+                text = str(content)
+            
+            if text.strip():
+                clean = text.strip().replace("\n", " ")
+                return clean[:40] + ("..." if len(clean) > 40 else "")
+    return "Nueva conversación"
+
+def scan_sessions() -> list[dict]:
+    """Scan session directories and return sorted list of metadata."""
+    sessions: list[dict] = []
+    seen: set[str] = set()
+    files: list[Path] = []
+
+    # Daily sessions (newest first)
+    if DAILY_DIR.exists():
+        for day_dir in sorted(DAILY_DIR.iterdir(), reverse=True):
+            if day_dir.is_dir():
+                files.extend(sorted(day_dir.glob("session_*.json"), reverse=True))
+
+    # MR sessions
+    if MR_SESSION_DIR.exists():
+        files.extend(
+            s for s in sorted(MR_SESSION_DIR.glob("*.json"), reverse=True)
+            if s.name != "session_latest.json"
+        )
+
+    # Root sessions
+    if SESSIONS_DIR.exists():
+        files.extend(sorted(SESSIONS_DIR.glob("session_*.json"), reverse=True))
+
+    for path in files:
+        try:
+            data = json.loads(path.read_text(encoding="utf-8", errors="replace"))
+            sid = data.get("session_id", path.stem)
+            if sid in seen:
+                continue
+            seen.add(sid)
+            
+            messages = data.get("messages", [])
+            title = build_title(messages)
+            
+            saved_at = data.get("saved_at", "")
+            if saved_at and len(saved_at) >= 19:
+                # Add time prefix: "HH:MM  Title"
+                title = f"{saved_at[11:16]}  {title}"
+            
+            sessions.append({
+                "id": sid, 
+                "title": title, 
+                "path": str(path), 
+                "messages": messages,
+                "saved_at": saved_at
+            })
+        except Exception:
+            continue
+
+    # Sort all found sessions by saved_at DESC
+    sessions.sort(key=lambda x: x.get("saved_at", ""), reverse=True)
+    return sessions[:50]
+
+def save_session(state, config: dict, session_id: str | None = None) -> str:
+    """Save AgentState to disk in standard Dulus format. Returns the session_id."""
+    if not state.messages:
+        return ""
+    
+    # User request: Only save if there is at least one user message
+    has_user_msg = any(m.get("role") == "user" for m in state.messages)
+    if not has_user_msg:
+        return ""
+
+    sid = session_id or uuid.uuid4().hex[:8]
+    now = datetime.datetime.now()
+    ts = now.strftime("%H%M%S")
+    date_str = now.strftime("%Y-%m-%d")
+    
+    # 1. Build payload
+    data = {
+        "session_id": sid,
+        "saved_at": now.strftime("%Y-%m-%d %H:%M:%S"),
+        "messages": state.messages,
+        "turn_count": getattr(state, "turn_count", len(state.messages) // 2),
+        "total_input_tokens": getattr(state, "total_input_tokens", 0),
+        "total_output_tokens": getattr(state, "total_output_tokens", 0),
+    }
+    payload = json.dumps(data, indent=2, default=str)
+
+    # 2. Save latest for /resume
+    MR_SESSION_DIR.mkdir(parents=True, exist_ok=True)
+    (MR_SESSION_DIR / "session_latest.json").write_text(payload, encoding="utf-8")
+
+    # 3. Save to daily folder
+    day_dir = DAILY_DIR / date_str
+    day_dir.mkdir(parents=True, exist_ok=True)
+    daily_path = day_dir / f"session_{ts}_{sid}.json"
+    daily_path.write_text(payload, encoding="utf-8")
+
+    # 4. Update history.json
+    try:
+        hist = {"total_turns": 0, "sessions": []}
+        if SESSION_HIST_FILE.exists():
+            try:
+                hist = json.loads(SESSION_HIST_FILE.read_text())
+            except Exception:
+                pass
+        
+        # Update or append
+        existing_idx = -1
+        for i, s in enumerate(hist.get("sessions", [])):
+            if s.get("session_id") == sid:
+                existing_idx = i
+                break
+        
+        if existing_idx >= 0:
+            hist["sessions"][existing_idx] = data
+        else:
+            hist["sessions"].append(data)
+            
+        # Prune history (keep 200)
+        limit = config.get("session_history_limit", 200)
+        if len(hist["sessions"]) > limit:
+            hist["sessions"] = hist["sessions"][-limit:]
+            
+        SESSION_HIST_FILE.write_text(json.dumps(hist, indent=2, default=str), encoding="utf-8")
+    except Exception:
+        pass # Don't crash UI if history.json fails
+
+    return sid
+
+def delete_session(session_id: str) -> bool:
+    """Delete all session files related to the given ID. Returns True if any deleted."""
+    if not session_id:
+        return False
+
+    deleted = False
+    
+    # 1. Scan and delete in MR_SESSION_DIR (except latest maybe?)
+    if MR_SESSION_DIR.exists():
+        for p in MR_SESSION_DIR.glob(f"*{session_id}*"):
+            try:
+                p.unlink()
+                deleted = True
+            except: pass
+
+    # 2. Daily sessions
+    if DAILY_DIR.exists():
+        for d in DAILY_DIR.iterdir():
+            if d.is_dir():
+                for p in d.glob(f"*{session_id}*"):
+                    try:
+                        p.unlink()
+                        deleted = True
+                    except: pass
+
+    # 3. Root sessions
+    if SESSIONS_DIR.exists():
+        for p in SESSIONS_DIR.glob(f"*{session_id}*"):
+            try:
+                p.unlink()
+                deleted = True
+            except: pass
+
+    # 4. Update history.json
+    if SESSION_HIST_FILE.exists():
+        try:
+            hist = json.loads(SESSION_HIST_FILE.read_text())
+            original_len = len(hist.get("sessions", []))
+            hist["sessions"] = [s for s in hist.get("sessions", []) if s.get("session_id") != session_id]
+            if len(hist["sessions"]) < original_len:
+                SESSION_HIST_FILE.write_text(json.dumps(hist, indent=2, default=str), encoding="utf-8")
+                deleted = True
+        except: pass
+
+    return deleted

gui/settings_dialog.py

@@ -0,0 +1,146 @@
+"""Settings popup for Dulus GUI."""
+from __future__ import annotations
+
+import os
+from typing import Optional
+
+import customtkinter as ctk
+
+from config import save_config
+from gui.themes import list_themes, set_theme
+
+THEME = {
+    "bg": "#1a1a2e",
+    "card": "#16213e",
+    "accent": "#00BCD4",
+    "accent_hover": "#00acc1",
+    "text": "#eaeaea",
+    "dim": "#888888",
+    "border": "#2a2a4a",
+}
+
+FONT_FAMILY = "Segoe UI"
+
+
+def _build_model_list() -> list[str]:
+    """Build list of provider/model strings from PROVIDERS registry."""
+    try:
+        from providers import PROVIDERS
+        models: list[str] = []
+        for pname, pmeta in PROVIDERS.items():
+            for m in pmeta.get("models", []):
+                models.append(f"{pname}/{m}")
+        return sorted(models) if models else ["kimi/kimi-k2.5"]
+    except Exception:
+        return [
+            "kimi/kimi-k2.5",
+            "openai/gpt-4o",
+            "anthropic/claude-3-5-sonnet",
+            "deepseek/deepseek-chat",
+            "ollama/llama3.3",
+        ]
+
+
+class SettingsDialog(ctk.CTkToplevel):
+    """Floating settings window."""
+
+    def __init__(self, master, config: dict) -> None:
+        super().__init__(master)
+        self.config = config
+        self.title("Settings")
+        self.geometry("480x520")
+        self.configure(fg_color=THEME["bg"])
+        self.transient(master)
+        self.grab_set()
+
+        # Center on parent
+        self.update_idletasks()
+        x = master.winfo_x() + (master.winfo_width() - self.winfo_width()) // 2
+        y = master.winfo_y() + (master.winfo_height() - self.winfo_height()) // 2
+        self.geometry(f"+{x}+{y}")
+
+        # Header
+        ctk.CTkLabel(
+            self,
+            text="⚙ Settings",
+            font=(FONT_FAMILY, 18, "bold"),
+            text_color=THEME["accent"],
+        ).pack(pady=(20, 15))
+
+        # Scrollable content
+        scroll = ctk.CTkScrollableFrame(self, fg_color="transparent", width=440)
+        scroll.pack(fill="both", expand=True, padx=20, pady=5)
+
+        # Model
+        ctk.CTkLabel(scroll, text="Model", font=(FONT_FAMILY, 12, "bold"), text_color=THEME["text"]).pack(anchor="w", pady=(10, 2))
+        self.model_var = ctk.StringVar(value=config.get("model", "kimi/kimi-k2.5"))
+        models = _build_model_list()
+        ctk.CTkOptionMenu(scroll, values=models, variable=self.model_var, fg_color=THEME["card"]).pack(fill="x", pady=2)
+
+        # Thinking
+        ctk.CTkLabel(scroll, text="Thinking Level", font=(FONT_FAMILY, 12, "bold"), text_color=THEME["text"]).pack(anchor="w", pady=(15, 2))
+        think_val = {0: "off", 1: "min", 2: "med", 3: "max", 4: "raw"}.get(config.get("thinking", 0), "off")
+        self.think_var = ctk.StringVar(value=think_val)
+        ctk.CTkOptionMenu(scroll, values=["off", "min", "med", "max", "raw"], variable=self.think_var, fg_color=THEME["card"]).pack(fill="x", pady=2)
+
+        # Verbose
+        ctk.CTkLabel(scroll, text="Verbose Mode", font=(FONT_FAMILY, 12, "bold"), text_color=THEME["text"]).pack(anchor="w", pady=(15, 2))
+        self.verbose_var = ctk.BooleanVar(value=config.get("verbose", False))
+        ctk.CTkSwitch(scroll, text="Enable verbose output", variable=self.verbose_var, progress_color=THEME["accent"]).pack(anchor="w", pady=2)
+
+        # Appearance mode
+        ctk.CTkLabel(scroll, text="Appearance", font=(FONT_FAMILY, 12, "bold"), text_color=THEME["text"]).pack(anchor="w", pady=(15, 2))
+        self.appearance_var = ctk.StringVar(value=config.get("appearance", "Dark"))
+        ctk.CTkOptionMenu(scroll, values=["Dark", "Light", "System"], variable=self.appearance_var, fg_color=THEME["card"]).pack(fill="x", pady=2)
+
+        # Color theme
+        ctk.CTkLabel(scroll, text="Color Theme", font=(FONT_FAMILY, 12, "bold"), text_color=THEME["text"]).pack(anchor="w", pady=(15, 2))
+        self.theme_var = ctk.StringVar(value=config.get("theme", "midnight"))
+        ctk.CTkOptionMenu(scroll, values=list_themes(), variable=self.theme_var, fg_color=THEME["card"]).pack(fill="x", pady=2)
+
+        # API Key (masked)
+        ctk.CTkLabel(scroll, text="API Key (active provider)", font=(FONT_FAMILY, 12, "bold"), text_color=THEME["text"]).pack(anchor="w", pady=(15, 2))
+        self.api_var = ctk.StringVar()
+        ctk.CTkEntry(scroll, textvariable=self.api_var, show="●", fg_color=THEME["card"], text_color=THEME["text"]).pack(fill="x", pady=2)
+
+        # Buttons
+        btn_frame = ctk.CTkFrame(self, fg_color="transparent")
+        btn_frame.pack(fill="x", padx=20, pady=15)
+
+        ctk.CTkButton(
+            btn_frame,
+            text="Cancel",
+            fg_color=THEME["border"],
+            hover_color="red",
+            command=self.destroy,
+        ).pack(side="left", padx=5)
+
+        ctk.CTkButton(
+            btn_frame,
+            text="Save",
+            fg_color=THEME["accent"],
+            hover_color=THEME["accent_hover"],
+            command=self._save,
+        ).pack(side="right", padx=5)
+
+    def _save(self) -> None:
+        self.config["model"] = self.model_var.get()
+        think_map = {"off": 0, "min": 1, "med": 2, "max": 3, "raw": 4}
+        self.config["thinking"] = think_map.get(self.think_var.get(), 0)
+        self.config["verbose"] = self.verbose_var.get()
+        self.config["appearance"] = self.appearance_var.get()
+        self.config["theme"] = self.theme_var.get()
+        ctk.set_appearance_mode(self.appearance_var.get())
+        # Notify parent to apply color theme
+        if hasattr(self.master, "apply_theme"):
+            self.master.apply_theme(self.theme_var.get())
+        key = self.api_var.get().strip()
+        if key:
+            pname = self.config.get("model", "").split("/")[0]
+            if pname:
+                self.config[f"{pname}_api_key"] = key
+        try:
+            save_config(self.config)
+        except Exception:
+            pass
+        self.destroy()