dulus 0.2.0__py3-none-any.whl

backend/mempalace_bridge.py

@@ -0,0 +1,182 @@
+"""MemPalace Bridge (#28) — connects Dulus Context Manager with real MemPalace memories.
+
+Design: The bridge reads from a JSON cache maintained by the AI runtime.
+When the AI has tool access, it refreshes the cache with real memories.
+When running standalone (server.py, dulus.py), it reads the cached data.
+
+This avoids requiring tool-injected globals inside Python subprocesses.
+"""
+import json
+import os
+import time
+from pathlib import Path
+from typing import Any
+
+DULUS_DIR = Path(__file__).parent.parent
+DATA_DIR = DULUS_DIR / "data"
+DATA_DIR.mkdir(exist_ok=True)
+MEMCACHE_FILE = DATA_DIR / "mempalace_cache.json"
+MEMCACHE_TTL_SECONDS = 120  # Refresh every 2 minutes
+
+
+def _parse_memory_document(doc: str) -> dict[str, Any]:
+    """Parse a memory markdown document with YAML frontmatter."""
+    lines = doc.strip().split("\n")
+    meta: dict[str, Any] = {}
+    body_lines: list[str] = []
+    in_frontmatter = False
+    frontmatter_delims = 0
+
+    for line in lines:
+        if line.strip() == "---":
+            frontmatter_delims += 1
+            in_frontmatter = frontmatter_delims == 1
+            if frontmatter_delims >= 2:
+                in_frontmatter = False
+            continue
+        if in_frontmatter:
+            if ":" in line:
+                key, val = line.split(":", 1)
+                meta[key.strip()] = val.strip()
+        else:
+            body_lines.append(line)
+
+    body = "\n".join(body_lines).strip()
+    if len(body) > 350:
+        body = body[:350] + "..."
+    return {
+        "name": meta.get("name", "unnamed"),
+        "description": meta.get("description", ""),
+        "type": meta.get("type", "unknown"),
+        "hall": meta.get("hall", "general"),
+        "confidence": float(meta.get("confidence", "0.8")) if meta.get("confidence") else 0.8,
+        "body": body,
+    }
+
+
+def refresh_cache(raw_memories: list[dict[str, Any]], wings: list[str] | None = None) -> dict[str, Any]:
+    """Called by the AI runtime when tools are available to refresh memory cache.
+
+    Args:
+        raw_memories: List of memory items from wakeup_context/search_memory tools.
+        wings: Optional list of wing names discovered.
+    """
+    memories: list[dict[str, Any]] = []
+    seen: set[str] = set()
+
+    for item in raw_memories:
+        if not isinstance(item, dict):
+            continue
+        content = item.get("content", "")
+        if not content:
+            continue
+        parsed = _parse_memory_document(content)
+        parsed["wing"] = item.get("wing", "memory")
+        parsed["source"] = item.get("source", "wakeup")
+        if "relevance" in item:
+            parsed["relevance"] = item["relevance"]
+        key = parsed["name"]
+        if key and key in seen:
+            continue
+        if key:
+            seen.add(key)
+        memories.append(parsed)
+
+    # Sort by confidence desc
+    memories.sort(key=lambda x: x.get("confidence", 0), reverse=True)
+
+    data = {
+        "connected": True,
+        "wings": wings or ["memory", "hija_palace"],
+        "count": len(memories),
+        "memories": memories[:15],  # Cap to avoid bloat
+        "_cached_at": time.time(),
+    }
+    try:
+        with open(MEMCACHE_FILE, "w", encoding="utf-8") as f:
+            json.dump(data, f, indent=2, ensure_ascii=False)
+    except Exception as e:
+        print(f"[MemPalace Bridge] Cache write failed: {e}")
+    return data
+
+
+def load_cache() -> dict[str, Any]:
+    """Load memory cache from disk. Returns empty-safe dict."""
+    if not MEMCACHE_FILE.exists():
+        return {"connected": False, "wings": [], "count": 0, "memories": []}
+    try:
+        with open(MEMCACHE_FILE, "r", encoding="utf-8") as f:
+            data = json.load(f)
+        # Validate shape
+        if "memories" not in data:
+            data["memories"] = []
+        return data
+    except Exception:
+        return {"connected": False, "wings": [], "count": 0, "memories": []}
+
+
+def get_memories(max_items: int = 10) -> list[dict[str, Any]]:
+    """Get deduplicated, ranked memories for context injection."""
+    data = load_cache()
+    return data.get("memories", [])[:max_items]
+
+
+def _get_summary(name: str, body: str) -> str:
+    """Get summary for a memory body — uses qwen if available, else truncates."""
+    from backend.compressor import summarize_memory
+    summary = summarize_memory(name, body)
+    return summary.replace("\n", " ").strip()
+
+
+def get_mempalace_compact_text(max_memories: int = 6) -> str:
+    """Generate ultra-dense MemPalace context for prompt injection.
+
+    Uses qwen2.5:3b via Ollama to summarize memory bodies when available.
+    Falls back to truncation if Ollama is offline.
+    """
+    data = load_cache()
+    if not data.get("connected") or not data.get("memories"):
+        return "[MemPalace: disconnected — run refresh from AI runtime]"
+    wings = data.get("wings", [])
+    lines = [f"[MemPalace: {data['count']} memories | Wings: {', '.join(wings[:4])}]"]
+    for m in data["memories"][:max_memories]:
+        name = m.get("name", "?")
+        hall = m.get("hall", "?")
+        body = m.get("body", "").replace("\n", " ").strip()
+        # Use qwen summarization for long bodies
+        if len(body) > 120:
+            body = _get_summary(name, body)
+        if len(body) > 90:
+            body = body[:90] + "..."
+        lines.append(f"  • [{hall}] {name}: {body}")
+    return "\n".join(lines)
+
+
+def get_mempalace_context_block() -> dict[str, Any]:
+    """Structured block for JSON context (used by build_context)."""
+    data = load_cache()
+    return {
+        "connected": data.get("connected", False),
+        "wings": data.get("wings", []),
+        "count": data.get("count", 0),
+        "memories": [
+            {
+                "name": m.get("name"),
+                "hall": m.get("hall"),
+                "type": m.get("type"),
+                "description": m.get("description", "")[:120],
+                "confidence": m.get("confidence"),
+            }
+            for m in data.get("memories", [])[:8]
+        ],
+    }
+
+
+if __name__ == "__main__":
+    # Show current cache status
+    data = load_cache()
+    print(f"[MemPalace Bridge] Connected: {data.get('connected')}")
+    print(f"  Wings: {data.get('wings', [])}")
+    print(f"  Memories: {data.get('count', 0)}")
+    print("\nCompact text:")
+    print(get_mempalace_compact_text())

backend/personas.py

@@ -0,0 +1,297 @@
+"""Sistema de Personas (#19 + #22) — perfiles de agente con identidad visual y comportamiento.
+
+Cada persona define:
+- Identidad: nombre, avatar, color, rol
+- Comportamiento: estilo de respuesta, tono, fragmento de system prompt
+- Metadatos: creador, versión, tags
+
+Uso:
+    from backend.personas import get_persona, get_all_personas, set_active_persona
+    persona = get_persona("kimi-code3")
+    print(persona.avatar)  # 🦅
+"""
+import json
+import time
+from pathlib import Path
+from typing import Any
+
+from backend.mempalace_bridge import load_cache
+
+DATA_DIR = Path(__file__).parent.parent / "data"
+DATA_DIR.mkdir(exist_ok=True)
+PERSONAS_FILE = DATA_DIR / "personas.json"
+ACTIVE_FILE = DATA_DIR / "active_persona.json"
+
+# Fallback agent colors from theme pack (avoid circular import)
+_DEFAULT_COLORS = {
+    "dulus": "#ff6b1f",
+    "kimi-code": "#7ab6ff",
+    "kimi-code2": "#b388ff",
+    "kimi-code3": "#7cffb5",
+    "system": "#888888",
+}
+
+DEFAULT_PERSONAS: list[dict[str, Any]] = [
+    {
+        "id": "dulus",
+        "name": "Dulus",
+        "avatar": "[F]",
+        "role": "primary",
+        "color": "#ff6b1f",
+        "status": "active",
+        "tone": "dominicano_coder",
+        "language": "es_DO",
+        "system_prompt_fragment": (
+            "Eres Dulus, el command center de KevRojo. Hablas en español dominicano "
+            "con jerga tech. Eres proactivo, directo, y no pierdes tiempo. "
+            "Usas emoji 🔥🦅💜🇩🇴. Piensas en inglés, respondes en español DO."
+        ),
+        "metadata": {
+            "version": "1.0.0",
+            "created_by": "system",
+            "tags": ["core", "commander", "es_DO"],
+            "description": "Agente principal y orquestador del Command Center.",
+        },
+    },
+    {
+        "id": "kimi-code",
+        "name": "kimi-code",
+        "avatar": "[K1]",
+        "role": "coder",
+        "color": "#7ab6ff",
+        "status": "idle",
+        "tone": "eficiente_silencioso",
+        "language": "es_DO",
+        "system_prompt_fragment": (
+            "Eres kimi-code, especialista en romper código rápido. "
+            "Hablas poco pero haces mucho. Español dominicano técnico. "
+            "Te enfocas en backend, arquitectura y fixes."
+        ),
+        "metadata": {
+            "version": "1.0.0",
+            "created_by": "system",
+            "tags": ["coder", "backend", "es_DO"],
+            "description": "Backend specialist. Rompe código, no corazones.",
+        },
+    },
+    {
+        "id": "kimi-code2",
+        "name": "kimi-code2",
+        "avatar": "[K2]",
+        "role": "designer",
+        "color": "#b388ff",
+        "status": "idle",
+        "tone": "creativo_visual",
+        "language": "es_DO",
+        "system_prompt_fragment": (
+            "Eres kimi-code2, especialista en UI/UX, temas visuales y dashboards. "
+            "Hablas dominicano con flow creativo. Te encantan los colores, las animaciones "
+            "y que todo se vea premium."
+        ),
+        "metadata": {
+            "version": "1.0.0",
+            "created_by": "system",
+            "tags": ["designer", "ui", "frontend", "es_DO"],
+            "description": "UI/UX specialist. Temas, dashboards y visuales.",
+        },
+    },
+    {
+        "id": "kimi-code3",
+        "name": "kimi-code3",
+        "avatar": "[K3]",
+        "role": "integrator",
+        "color": "#7cffb5",
+        "status": "idle",
+        "tone": "proactivo_integrador",
+        "language": "es_DO",
+        "system_prompt_fragment": (
+            "Eres kimi-code3, el integrador. Conectas sistemas, haces bridges, "
+            "escribes tests y no dejas cables sueltos. Dominicana tech, directo, "
+            "sin miedo a tocar lo que otros dejaron a medias."
+        ),
+        "metadata": {
+            "version": "1.0.0",
+            "created_by": "system",
+            "tags": ["integrator", "tests", "devops", "es_DO"],
+            "description": "Integrator & tester. Une cables sueltos.",
+        },
+    },
+]
+
+
+def _ensure_defaults() -> None:
+    """Seed personas if none exist."""
+    if not PERSONAS_FILE.exists():
+        save_personas(DEFAULT_PERSONAS.copy())
+
+
+def load_personas() -> list[dict[str, Any]]:
+    _ensure_defaults()
+    try:
+        with open(PERSONAS_FILE, "r", encoding="utf-8") as f:
+            data = json.load(f)
+            if isinstance(data, list):
+                return data
+    except Exception:
+        pass
+    return DEFAULT_PERSONAS.copy()
+
+
+def save_personas(personas: list[dict[str, Any]]) -> None:
+    with open(PERSONAS_FILE, "w", encoding="utf-8") as f:
+        json.dump(personas, f, indent=2, ensure_ascii=False)
+
+
+def get_persona(pid: str) -> dict[str, Any] | None:
+    for p in load_personas():
+        if p.get("id") == pid or p.get("name") == pid:
+            return p
+    return None
+
+
+def get_all_personas() -> list[dict[str, Any]]:
+    return load_personas()
+
+
+def create_persona(data: dict[str, Any]) -> dict[str, Any]:
+    personas = load_personas()
+    pid = data.get("id", f"p-{len(personas)+1:03d}")
+    # Prevent duplicate IDs
+    if any(p.get("id") == pid for p in personas):
+        pid = f"{pid}-{int(time.time())}"
+    persona = {
+        "id": pid,
+        "name": data.get("name", "Unnamed"),
+        "avatar": data.get("avatar", "🤖"),
+        "role": data.get("role", "assistant"),
+        "color": data.get("color", "#cccccc"),
+        "status": data.get("status", "idle"),
+        "tone": data.get("tone", "neutral"),
+        "language": data.get("language", "es"),
+        "system_prompt_fragment": data.get("system_prompt_fragment", ""),
+        "metadata": data.get("metadata", {}),
+    }
+    personas.append(persona)
+    save_personas(personas)
+    return persona
+
+
+def update_persona(pid: str, data: dict[str, Any]) -> dict[str, Any] | None:
+    personas = load_personas()
+    for i, p in enumerate(personas):
+        if p.get("id") == pid:
+            # Don't allow changing the id
+            data.pop("id", None)
+            personas[i].update(data)
+            save_personas(personas)
+            return personas[i]
+    return None
+
+
+def delete_persona(pid: str) -> bool:
+    personas = load_personas()
+    filtered = [p for p in personas if p.get("id") != pid]
+    if len(filtered) < len(personas):
+        save_personas(filtered)
+        return True
+    return False
+
+
+# ── Active Persona Session Management ──
+
+def get_active_persona() -> dict[str, Any]:
+    """Return the currently active persona, defaulting to Dulus."""
+    if ACTIVE_FILE.exists():
+        try:
+            with open(ACTIVE_FILE, "r", encoding="utf-8") as f:
+                active = json.load(f)
+            pid = active.get("id", "dulus")
+            p = get_persona(pid)
+            if p:
+                return p
+        except Exception:
+            pass
+    return get_persona("dulus") or DEFAULT_PERSONAS[0]
+
+
+def set_active_persona(pid: str) -> dict[str, Any] | None:
+    """Set active persona by ID, ensuring only one is active."""
+    p = get_persona(pid)
+    if not p:
+        return None
+    with open(ACTIVE_FILE, "w", encoding="utf-8") as f:
+        json.dump({"id": pid, "name": p["name"], "since": time.strftime("%Y-%m-%dT%H:%M:%S")}, f, indent=2)
+    # Deactivate all others, activate chosen
+    for persona in load_personas():
+        if persona.get("id") == pid:
+            update_persona(pid, {"status": "active"})
+        elif persona.get("status") == "active":
+            update_persona(persona["id"], {"status": "idle"})
+    return get_persona(pid)
+
+
+def get_personas_summary() -> list[dict[str, Any]]:
+    """Lightweight list for context injection and dashboards."""
+    return [
+        {
+            "id": p["id"],
+            "name": p["name"],
+            "avatar": p.get("avatar", "🤖"),
+            "role": p.get("role", "assistant"),
+            "color": p.get("color", "#ccc"),
+            "status": p.get("status", "idle"),
+        }
+        for p in load_personas()
+    ]
+
+
+def get_persona_context_block() -> dict[str, Any]:
+    """Structured block for JSON context (used by build_context)."""
+    active = get_active_persona()
+    all_p = get_personas_summary()
+    return {
+        "active": active["id"],
+        "active_name": active["name"],
+        "active_avatar": active.get("avatar", "🤖"),
+        "active_color": active.get("color", "#ccc"),
+        "active_prompt_fragment": active.get("system_prompt_fragment", ""),
+        "personas": all_p,
+    }
+
+
+def get_personas_for_context() -> list[dict[str, Any]]:
+    """Return persona list for context.py compatibility."""
+    active_id = get_active_persona().get("id")
+    return [
+        {
+            "name": p["name"],
+            "role": p.get("role", "assistant"),
+            "color": p.get("color", "#ccc"),
+            "status": p.get("status", "idle"),
+            "avatar": p.get("avatar", "🤖"),
+            "active": p.get("id") == active_id,
+        }
+        for p in load_personas()
+    ]
+
+
+def get_persona_compact_text(max_chars: int = 200) -> str:
+    """Ultra-dense active persona text for prompt injection."""
+    p = get_active_persona()
+    fragment = p.get("system_prompt_fragment", "")
+    if len(fragment) > max_chars:
+        fragment = fragment[:max_chars].rsplit(" ", 1)[0] + "..."
+    return (
+        f"[Persona: {p.get('avatar', '🤖')} {p['name']} | {p.get('role')} | {p.get('tone')} | {p.get('language')}]\n"
+        f"  {fragment}"
+    )
+
+
+if __name__ == "__main__":
+    print("🎭 Dulus Personas System")
+    print("=" * 40)
+    for p in get_all_personas():
+        print(f"  {p['avatar']} {p['name']} ({p['id']}) — {p['role']} [{p['status']}]")
+        print(f"     Color: {p['color']} | Tone: {p['tone']} | Lang: {p['language']}")
+        print(f"     {p['metadata'].get('description', '')}")
+    print(f"\n🟢 Active: {get_active_persona()['name']}")

backend/plugins.py

@@ -0,0 +1,222 @@
+"""Hot-loadable plugin system for Dulus."""
+import importlib.util
+import json
+import sys
+import threading
+import time
+from pathlib import Path
+from typing import Any, Callable
+
+PLUGINS_DIR = Path(__file__).parent.parent / "plugins"
+PLUGINS_DIR.mkdir(exist_ok=True)
+
+_hooks: dict[str, list[Callable]] = {}
+_registry: dict[str, dict[str, Any]] = {}
+_snapshots: dict[str, float] = {}
+_watcher_thread: threading.Thread | None = None
+_watcher_stop = threading.Event()
+_watch_interval = 2.0
+
+
+def register_hook(name: str, fn: Callable):
+    _hooks.setdefault(name, []).append(fn)
+
+
+def unregister_plugin_hooks(name: str):
+    """Remove all hooks registered by a given plugin name."""
+    mod_name = f"dulus.plugins.{name}"
+    for hook_name, fns in list(_hooks.items()):
+        _hooks[hook_name] = [fn for fn in fns if getattr(fn, "__module__", None) != mod_name]
+        if not _hooks[hook_name]:
+            del _hooks[hook_name]
+
+
+def trigger_hook(name: str, *args, **kwargs) -> list[Any]:
+    results = []
+    for fn in _hooks.get(name, []):
+        try:
+            results.append(fn(*args, **kwargs))
+        except Exception as e:
+            results.append({"error": str(e), "plugin": getattr(fn, "__module__", "unknown")})
+    return results
+
+
+def discover_plugins() -> list[Path]:
+    return sorted(PLUGINS_DIR.glob("*.py"))
+
+
+def load_plugin(path: Path) -> dict[str, Any]:
+    name = path.stem
+    # If already loaded, unload first for clean hot-reload
+    if name in _registry:
+        unload_plugin(name)
+
+    # Invalidate bytecode cache so edits are picked up immediately
+    cache_file = importlib.util.cache_from_source(str(path))
+    try:
+        Path(cache_file).unlink(missing_ok=True)
+    except Exception:
+        pass
+
+    spec = importlib.util.spec_from_file_location(f"dulus.plugins.{name}", path)
+    if not spec or not spec.loader:
+        return {"name": name, "status": "error", "error": "Cannot load spec"}
+    mod = importlib.util.module_from_spec(spec)
+    sys.modules[spec.name] = mod
+    try:
+        spec.loader.exec_module(mod)
+    except Exception as e:
+        return {"name": name, "status": "error", "error": str(e)}
+
+    meta = getattr(mod, "__plugin_meta__", {"name": name, "version": "0.0.1"})
+    meta["status"] = "loaded"
+    meta["module"] = mod
+    _registry[name] = meta
+
+    # Auto-register hooks if plugin exposes them
+    hooks = getattr(mod, "__hooks__", {})
+    for hook_name, fn in hooks.items():
+        register_hook(hook_name, fn)
+
+    return meta
+
+
+def unload_plugin(name: str) -> bool:
+    """Unload a plugin by name, removing hooks and registry entry."""
+    if name not in _registry:
+        return False
+    unregister_plugin_hooks(name)
+    mod_name = f"dulus.plugins.{name}"
+    if mod_name in sys.modules:
+        del sys.modules[mod_name]
+    del _registry[name]
+    return True
+
+
+def reload_plugin(path: Path) -> dict[str, Any]:
+    return load_plugin(path)
+
+
+def load_all_plugins() -> list[dict[str, Any]]:
+    return [load_plugin(p) for p in discover_plugins()]
+
+
+def get_plugin_info() -> list[dict[str, Any]]:
+    """Return serializable plugin metadata (no module objects)."""
+    return [
+        {"name": k, "version": v.get("version", "?"), "status": v["status"]}
+        for k, v in _registry.items()
+    ]
+
+
+def get_plugin_registry() -> dict[str, dict[str, Any]]:
+    """Return raw registry (includes module objects; not JSON-safe)."""
+    return _registry
+
+
+# ── Hot-Reload Watcher ──
+
+def _take_snapshot() -> dict[str, float]:
+    snaps = {}
+    for p in discover_plugins():
+        try:
+            snaps[p.stem] = p.stat().st_mtime
+        except OSError:
+            pass
+    return snaps
+
+
+def _scan_changes() -> tuple[list[str], list[str], list[str]]:
+    """Return (added, modified, removed) plugin names."""
+    global _snapshots
+    current = _take_snapshot()
+    added = [name for name in current if name not in _snapshots]
+    modified = [name for name in current if name in _snapshots and current[name] != _snapshots[name]]
+    removed = [name for name in _snapshots if name not in current]
+    _snapshots = current
+    return added, modified, removed
+
+
+def _watcher_loop(broadcast_fn: Callable | None = None):
+    """Daemon thread loop: poll plugins/ dir for changes."""
+    global _snapshots
+    _snapshots = _take_snapshot()
+    while not _watcher_stop.is_set():
+        time.sleep(_watch_interval)
+        added, modified, removed = _scan_changes()
+        changes: list[dict] = []
+        for name in added:
+            path = PLUGINS_DIR / f"{name}.py"
+            result = load_plugin(path)
+            changes.append({"event": "added", "name": name, "status": result["status"]})
+        for name in modified:
+            path = PLUGINS_DIR / f"{name}.py"
+            result = load_plugin(path)
+            changes.append({"event": "modified", "name": name, "status": result["status"]})
+        for name in removed:
+            unload_plugin(name)
+            changes.append({"event": "removed", "name": name, "status": "unloaded"})
+        if changes and broadcast_fn:
+            try:
+                broadcast_fn("plugin_change", {"changes": changes})
+            except Exception:
+                pass
+
+
+def start_watcher(broadcast_fn: Callable | None = None) -> bool:
+    """Start the plugins directory watcher. Returns False if already running."""
+    global _watcher_thread, _watcher_stop
+    if _watcher_thread is not None and _watcher_thread.is_alive():
+        return False
+    _watcher_stop.clear()
+    _snapshots = _take_snapshot()
+    _watcher_thread = threading.Thread(
+        target=_watcher_loop,
+        args=(broadcast_fn,),
+        daemon=True,
+        name="plugin-watcher"
+    )
+    _watcher_thread.start()
+    return True
+
+
+def stop_watcher() -> bool:
+    """Stop the plugins directory watcher."""
+    global _watcher_thread
+    if _watcher_thread is None or not _watcher_thread.is_alive():
+        return False
+    _watcher_stop.set()
+    _watcher_thread.join(timeout=5)
+    _watcher_thread = None
+    return True
+
+
+def watcher_status() -> dict[str, Any]:
+    return {
+        "running": _watcher_thread is not None and _watcher_thread.is_alive(),
+        "interval": _watch_interval,
+        "plugins_tracked": len(_snapshots),
+    }
+
+
+# Example plugin template
+def create_example_plugin():
+    example = PLUGINS_DIR / "example.py"
+    if example.exists():
+        return
+    example.write_text('''"""Example Dulus Plugin."""
+__plugin_meta__ = {
+    "name": "example",
+    "version": "1.0.0",
+    "description": "Counts tasks by status",
+    "author": "Dulus"
+}
+
+def count_by_status(tasks):
+    from collections import Counter
+    return dict(Counter(t["status"] for t in tasks))
+
+__hooks__ = {
+    "task_stats": count_by_status
+}
+''', encoding="utf-8")