dulus 0.2.0__py3-none-any.whl

backend/context.py

@@ -0,0 +1,329 @@
+"""Smart Context Manager (#23 + #28) — generates optimized context for LLM sessions."""
+import json
+import os
+import subprocess
+import time
+from pathlib import Path
+from typing import Any
+
+from backend.compressor import compress
+from backend.mempalace_bridge import get_mempalace_compact_text, get_mempalace_context_block
+from backend.personas import get_personas_for_context, get_active_persona, get_persona_compact_text
+from backend.tasks import load_tasks
+
+DATA_DIR = Path(__file__).parent.parent / "data"
+DATA_DIR.mkdir(exist_ok=True)
+CONTEXT_FILE = DATA_DIR / "context.json"
+
+
+def run_git(args: list[str]) -> str:
+    try:
+        return subprocess.check_output(
+            ["git"] + args, cwd=Path(__file__).parent.parent, stderr=subprocess.DEVNULL, text=True
+        )
+    except Exception:
+        return ""
+
+
+def get_recent_commits(n: int = 5) -> list[dict[str, str]]:
+    out = run_git(["log", f"-{n}", "--pretty=format:%h|%s|%an|%ad", "--date=short"])
+    commits = []
+    for line in out.strip().split("\n"):
+        if "|" in line:
+            h, s, a, d = line.split("|", 3)
+            commits.append({"hash": h, "subject": s, "author": a, "date": d})
+    return commits
+
+
+def get_changed_files() -> list[str]:
+    out = run_git(["diff", "--name-only", "HEAD~1"])
+    return [f for f in out.strip().split("\n") if f]
+
+
+def get_repo_stats() -> dict[str, Any]:
+    root = Path(__file__).parent.parent
+    stats = {"files": 0, "lines": 0, "languages": {}}
+    for path in root.rglob("*"):
+        if path.is_file() and ".git" not in path.parts and "__pycache__" not in path.parts:
+            stats["files"] += 1
+            ext = path.suffix or "no_ext"
+            try:
+                lc = sum(1 for _ in path.open("r", encoding="utf-8", errors="ignore"))
+                stats["lines"] += lc
+                stats["languages"][ext] = stats["languages"].get(ext, 0) + lc
+            except Exception:
+                pass
+    return stats
+
+
+def get_active_tasks_summary() -> list[dict[str, Any]]:
+    tasks = load_tasks()
+    return [
+        {"id": t["id"], "subject": t["subject"], "status": t["status"], "owner": t["owner"], "phase": t.get("metadata", {}).get("phase", "")}
+        for t in tasks if t["status"] in ("pending", "in_progress")
+    ]
+
+
+def build_context() -> dict[str, Any]:
+    """Build comprehensive session context with real MemPalace memories."""
+    active = get_active_persona()
+    context = {
+        "session": {
+            "mode": "proactive",
+            "agent": active["name"],
+            "agent_id": active["id"],
+            "user": "KevRojo",
+            "location": "RD"
+        },
+        "project": {
+            "name": "Dulus Command Center",
+            "repo_stats": get_repo_stats(),
+            "recent_commits": get_recent_commits(),
+            "recent_changes": get_changed_files()
+        },
+        "tasks": {
+            "active": get_active_tasks_summary(),
+            "total": len(get_active_tasks_summary())
+        },
+        "agents": get_personas_for_context(),
+        "persona": {
+            "id": active["id"],
+            "name": active["name"],
+            "role": active["role"],
+            "color": active["color"],
+            "avatar": active.get("avatar", "🤖"),
+            "tone": active["tone"],
+        },
+        "memory": get_mempalace_context_block()
+    }
+    with open(CONTEXT_FILE, "w", encoding="utf-8") as f:
+        json.dump(context, f, indent=2, ensure_ascii=False)
+    return context
+
+
+def load_context() -> dict[str, Any]:
+    if CONTEXT_FILE.exists():
+        with open(CONTEXT_FILE, "r", encoding="utf-8") as f:
+            return json.load(f)
+    return build_context()
+
+
+# ─────────── Token & Smart Context Management ───────────
+
+def get_user_max_tokens() -> int:
+    try:
+        config_file = Path.home() / ".dulus" / "config.json"
+        if config_file.exists():
+            with open(config_file, "r", encoding="utf-8") as f:
+                data = json.loads(f.read())
+                return int(data.get("max_tokens", 8000))
+    except Exception:
+        pass
+    return 8000
+
+MAX_CONTEXT_TOKENS = get_user_max_tokens()
+COMPACT_THRESHOLD = 0.75
+EMERGENCY_THRESHOLD = 0.90
+COMPACTION_HISTORY: list[dict[str, Any]] = []
+
+
+def estimate_tokens(text: str) -> int:
+    """Rough token estimation: ~4 chars per token for English/code."""
+    if not text:
+        return 0
+    return max(1, len(text) // 4)
+
+
+def get_context_mode(token_pct: float) -> str:
+    if token_pct >= EMERGENCY_THRESHOLD:
+        return "emergency"
+    if token_pct >= COMPACT_THRESHOLD:
+        return "compact"
+    return "normal"
+
+
+def record_compaction(reason: str, before_tokens: int, after_tokens: int) -> None:
+    COMPACTION_HISTORY.append({
+        "timestamp": time.strftime("%Y-%m-%dT%H:%M:%S"),
+        "reason": reason,
+        "before_tokens": before_tokens,
+        "after_tokens": after_tokens,
+        "saved_tokens": before_tokens - after_tokens,
+    })
+    # Keep last 20
+    while len(COMPACTION_HISTORY) > 20:
+        COMPACTION_HISTORY.pop(0)
+
+
+def build_smart_context() -> dict[str, Any]:
+    """Build context with token estimation and mode detection.
+
+    When mode is compact or emergency, applies rule-based compression
+    to keep context under budget. qwen2.5:3b is used for memory
+    summarization via mempalace_bridge, not for full-context compression.
+    """
+    ctx = build_context()
+    compact_text = get_compact_context()
+    tokens = estimate_tokens(compact_text)
+    
+    try:
+        import sys
+        if "webchat_server" in sys.modules:
+            from webchat_server import STATE
+            if STATE and hasattr(STATE, "messages"):
+                for msg in STATE.messages:
+                    tokens += estimate_tokens(str(msg))
+    except Exception:
+        pass
+
+    pct = round(tokens / MAX_CONTEXT_TOKENS, 4)
+    mode = get_context_mode(pct)
+
+    compressed_text = compact_text
+    compressor_method = "none"
+
+    if mode in ("compact", "emergency"):
+        target = 400 if mode == "compact" else 200
+        result = compress(compact_text, max_tokens=target)
+        compressed_text = result["compressed"]
+        compressor_method = result["method"]
+        record_compaction(
+            reason=f"auto-{mode}",
+            before_tokens=result["before_tokens"],
+            after_tokens=result["after_tokens"],
+        )
+
+    ctx["smart_context"] = {
+        "tokens_used": estimate_tokens(compressed_text),
+        "tokens_max": MAX_CONTEXT_TOKENS,
+        "usage_percent": pct,
+        "mode": mode,
+        "thresholds": {
+            "compact": COMPACT_THRESHOLD,
+            "emergency": EMERGENCY_THRESHOLD,
+        },
+        "compact_text": compressed_text,
+        "compressor_method": compressor_method,
+        "compaction_history": COMPACTION_HISTORY,
+    }
+
+    with open(CONTEXT_FILE, "w", encoding="utf-8") as f:
+        json.dump(ctx, f, indent=2, ensure_ascii=False)
+    return ctx
+
+
+def force_compaction() -> dict[str, Any]:
+    """Manually force compression of the context."""
+    ctx = build_context()
+    compact_text = get_compact_context()
+    result = compress(compact_text, max_tokens=200)
+    compressed_text = result["compressed"]
+    compressor_method = result["method"]
+    record_compaction(
+        reason="manual-force",
+        before_tokens=result["before_tokens"],
+        after_tokens=result["after_tokens"],
+    )
+    
+    # Actually trim the STATE.messages array so live token count decreases
+    try:
+        import sys
+        if "webchat_server" in sys.modules:
+            from webchat_server import STATE
+            if STATE and hasattr(STATE, "messages") and len(STATE.messages) > 10:
+                # Keep system block (first message) and the last ~6 messages
+                new_msgs = [STATE.messages[0]]
+                
+                # Add a system message notifying of the compaction
+                new_msgs.append({
+                    "role": "system",
+                    "content": "[SYSTEM EVENT: Conversation history was forcefully compacted by the user. Older messages were purged.]"
+                })
+                
+                # Handle the remaining messages carefully to avoid breaking API tool_call parity
+                raw_kept = STATE.messages[-6:]
+                sanitized_kept = []
+                for m in raw_kept:
+                    # Drop tool responses entirely to avoid orphaned IDs
+                    if m.get("role") == "tool":
+                        continue
+                        
+                    sm = dict(m)
+                    # Strip any outgoing tool_calls from assistant messages
+                    if "tool_calls" in sm:
+                        del sm["tool_calls"]
+                    if "tool_call_id" in sm:
+                        del sm["tool_call_id"]
+                        
+                    # If this leaves an assistant message with NO content, drop it too
+                    if sm.get("role") == "assistant" and not sm.get("content"):
+                        continue
+                        
+                    # Ensure content is stringified if it was a list of chunks
+                    if isinstance(sm.get("content"), list):
+                        sm["content"] = "\n".join(
+                            c.get("text", "") for c in sm["content"] if c.get("type", "") == "text"
+                        )
+                        
+                    sanitized_kept.append(sm)
+                    
+                new_msgs.extend(sanitized_kept)
+                STATE.messages = new_msgs
+                import webchat_server
+                webchat_server.broadcast_event("chat_cleared", {}) # Force UI refresh if needed
+    except Exception as e:
+        print("Compaction physical trim error:", e)
+    
+    tokens = estimate_tokens(compressed_text)
+    
+    try:
+        import sys
+        if "webchat_server" in sys.modules:
+            from webchat_server import STATE
+            if STATE and hasattr(STATE, "messages"):
+                for msg in STATE.messages:
+                    tokens += estimate_tokens(str(msg))
+    except Exception:
+        pass
+
+    pct = round(tokens / MAX_CONTEXT_TOKENS, 4)
+    mode = get_context_mode(pct)
+    
+    ctx["smart_context"] = {
+        "tokens_used": tokens,
+        "tokens_max": MAX_CONTEXT_TOKENS,
+        "usage_percent": pct,
+        "mode": "compact",
+        "thresholds": {"compact": COMPACT_THRESHOLD, "emergency": EMERGENCY_THRESHOLD},
+        "compact_text": compressed_text,
+        "compressor_method": compressor_method,
+        "compaction_history": COMPACTION_HISTORY,
+    }
+    with open(CONTEXT_FILE, "w", encoding="utf-8") as f:
+        json.dump(ctx, f, indent=2, ensure_ascii=False)
+    return ctx
+
+
+def get_compact_context(max_tokens_estimate: int = 800) -> str:
+    """Generate ultra-dense text context for LLM prompt injection."""
+    ctx = build_context()
+    lines = [
+        "[DULUS CONTEXT]",
+        f"Session: {ctx['session']['mode']} | Agent: {ctx['session']['agent']} | User: {ctx['session']['user']}",
+        f"Project: {ctx['project']['name']} | Files: {ctx['project']['repo_stats']['files']} | Lines: {ctx['project']['repo_stats']['lines']}",
+        "Active Tasks:"
+    ]
+    for t in ctx["tasks"]["active"][:5]:
+        lines.append(f"  • {t['id']} [{t['status']}] {t['subject']} ({t['owner']}, {t['phase']})")
+    lines.append("Agents:")
+    for a in ctx["agents"]:
+        marker = " [ACTIVE]" if a.get("active") else ""
+        lines.append(f"  • {a.get('avatar', '🤖')} {a['name']} ({a['role']}) - {a['status']}{marker}")
+    lines.append("Recent Commits:")
+    for c in ctx["project"]["recent_commits"][:3]:
+        lines.append(f"  • {c['hash']} {c['subject']} by {c['author']}")
+    # ── Persona activa (#19/#22) ──
+    lines.append(get_persona_compact_text())
+    # ── MemPalace real memories (#28) ──
+    lines.append(get_mempalace_compact_text())
+    return "\n".join(lines)

backend/githook.py

@@ -0,0 +1,166 @@
+"""Git hook management for Dulus."""
+import os
+import subprocess
+import sys
+from pathlib import Path
+
+HOOK_TEMPLATE = '''#!/usr/bin/env python3
+"""Dulus Pre-Commit Hook — auto-installed by `dulus git-hook install`"""
+import subprocess
+import sys
+from pathlib import Path
+
+BOLD = "\033[1m"
+RED = "\033[91m"
+GREEN = "\033[92m"
+YELLOW = "\033[93m"
+RESET = "\033[0m"
+MAX_MB = 10
+
+def log(msg, level="info"):
+    colors = {"error": RED, "ok": GREEN, "warn": YELLOW, "info": ""}
+    print(f"{colors.get(level, '')}{BOLD}[dulus-hook]{RESET} {msg}")
+
+def get_staged():
+    r = subprocess.run(
+        ["git", "diff", "--cached", "--name-only", "--diff-filter=ACM"],
+        capture_output=True, text=True
+    )
+    return [f for f in r.stdout.strip().split("\\n") if f]
+
+def check_trailing(files):
+    issues = []
+    for f in files:
+        p = Path(f)
+        if not p.exists() or p.stat().st_size > 1024*1024:
+            continue
+        try:
+            with open(f, "r", encoding="utf-8") as fh:
+                for i, line in enumerate(fh, 1):
+                    if line.rstrip() != line.rstrip(" \\t"):
+                        issues.append((f, i, "trailing whitespace"))
+        except Exception:
+            pass
+    return issues
+
+def check_syntax(files):
+    issues = []
+    for f in files:
+        if not f.endswith(".py"):
+            continue
+        r = subprocess.run([sys.executable, "-m", "py_compile", f],
+                          capture_output=True, text=True)
+        if r.returncode != 0:
+            issues.append((f, 0, f"syntax error: {r.stderr.strip()[:80]}"))
+    return issues
+
+def check_size(files):
+    return [(f, 0, f"file > {MAX_MB}MB")
+            for f in files if Path(f).exists() and Path(f).stat().st_size > MAX_MB*1024*1024]
+
+def check_tasks(files):
+    p = Path(".dulus-context/tasks.json")
+    if not p.exists():
+        return []
+    try:
+        import json
+        data = json.loads(p.read_text(encoding="utf-8"))
+        for t in data.get("tasks", []):
+            if t.get("status") == "completed" and t.get("blocked_by"):
+                return [(str(p), 0, f"Task #{t['id']} completed but has blockers")]
+    except Exception:
+        pass
+    return []
+
+def main():
+    log("Running Dulus pre-commit checks...", "info")
+    files = get_staged()
+    if not files:
+        log("No staged files - skipping", "ok")
+        sys.exit(0)
+
+    checks = [
+        ("trailing whitespace", check_trailing),
+        ("Python syntax", check_syntax),
+        ("large files", check_size),
+        ("task consistency", check_tasks),
+    ]
+    all_issues = []
+    for name, fn in checks:
+        issues = fn(files)
+        if issues:
+            all_issues.extend(issues)
+            log(f"{name}: {len(issues)} issue(s)", "warn")
+
+    if all_issues:
+        log(f"Found {len(all_issues)} issue(s):", "error")
+        for f, line, msg in all_issues[:10]:
+            loc = f":{line}" if line else ""
+            print(f"  {RED}[X]{RESET} {f}{loc} - {msg}")
+        if len(all_issues) > 10:
+            print(f"  ... and {len(all_issues)-10} more")
+        log("Commit blocked. Fix or use --no-verify to bypass.", "error")
+        sys.exit(1)
+
+    log("All checks passed! Dulus out.", "ok")
+    sys.exit(0)
+
+if __name__ == "__main__":
+    main()
+'''
+
+
+def _hook_path():
+    git_dir = Path(".git")
+    if not git_dir.exists():
+        return None
+    return git_dir / "hooks" / "pre-commit"
+
+
+def is_dulus_hook(path: Path) -> bool:
+    return path.exists() and "Dulus Pre-Commit Hook" in path.read_text(encoding="utf-8")
+
+
+def install():
+    hook = _hook_path()
+    if hook is None:
+        print("[X] Not a git repository.")
+        sys.exit(1)
+
+    if hook.exists():
+        backup = hook.with_suffix(".backup")
+        hook.rename(backup)
+        print(f"[BK] Backed up existing hook to {backup.name}")
+
+    hook.write_text(HOOK_TEMPLATE, encoding="utf-8")
+    try:
+        hook.chmod(0o755)
+    except Exception:
+        pass
+    print("[OK] Dulus pre-commit hook installed!")
+    print("     Checks: trailing whitespace / Python syntax / large files / task consistency")
+
+
+def uninstall():
+    hook = _hook_path()
+    if hook is None:
+        print("[X] Not a git repository.")
+        sys.exit(1)
+
+    if is_dulus_hook(hook):
+        hook.unlink()
+        print("[OK] Dulus pre-commit hook removed.")
+    else:
+        print("[!] No Dulus hook found.")
+
+
+def status():
+    hook = _hook_path()
+    if hook is None:
+        print("[X] Not a git repository.")
+        sys.exit(1)
+
+    if is_dulus_hook(hook):
+        print("[OK] Dulus pre-commit hook is active.")
+    else:
+        print("[--] Dulus pre-commit hook is NOT installed.")

backend/marketplace.py

@@ -0,0 +1,141 @@
+"""Plugin Marketplace — esqueleto y registry de plugins disponibles. (#20)
+
+Este módulo maneja:
+- Registry local de plugins conocidos
+- Metadatos de plugins del marketplace
+- Instalación simulada/remota de plugins
+"""
+import json
+from pathlib import Path
+from typing import Any
+
+DATA_DIR = Path(__file__).parent.parent / "data"
+DATA_DIR.mkdir(exist_ok=True)
+MARKETPLACE_FILE = DATA_DIR / "marketplace.json"
+
+# Plugins pre-registrados en el marketplace oficial
+DEFAULT_REGISTRY: list[dict[str, Any]] = [
+    {
+        "id": "mp-themes",
+        "name": "Theme Switcher",
+        "version": "1.0.0",
+        "author": "Dulus Team",
+        "description": "Switch between Cyberpunk, Sakura, Sunset and Gold themes in real-time.",
+        "tags": ["ui", "themes", "dashboard"],
+        "downloads": 420,
+        "rating": 4.8,
+        "installed": False,
+        "source": "builtin",
+    },
+    {
+        "id": "mp-git-stats",
+        "name": "Git Stats Visualizer",
+        "version": "0.9.0",
+        "author": "kimi-code",
+        "description": "Visualize commit history, contributor stats and code churn.",
+        "tags": ["git", "visualization", "stats"],
+        "downloads": 128,
+        "rating": 4.5,
+        "installed": False,
+        "source": "community",
+    },
+    {
+        "id": "mp-agent-profiles",
+        "name": "Agent Profiles",
+        "version": "1.1.0",
+        "author": "kimi-code2",
+        "description": "Personas system with avatars, colors and identity per agent.",
+        "tags": ["agents", "personas", "identity"],
+        "downloads": 256,
+        "rating": 4.9,
+        "installed": False,
+        "source": "community",
+    },
+    {
+        "id": "mp-mempalace-bridge",
+        "name": "MemPalace Bridge",
+        "version": "0.5.0",
+        "author": "Dulus Team",
+        "description": "Connect Smart Context to MemPalace for infinite agent memory.",
+        "tags": ["memory", "integration", "mempalace"],
+        "downloads": 69,
+        "rating": 4.2,
+        "installed": False,
+        "source": "official",
+    },
+]
+
+
+def load_registry() -> list[dict[str, Any]]:
+    if MARKETPLACE_FILE.exists():
+        try:
+            with open(MARKETPLACE_FILE, "r", encoding="utf-8") as f:
+                data = json.load(f)
+                if isinstance(data, list) and data:
+                    return data
+        except Exception:
+            pass
+    save_registry(DEFAULT_REGISTRY)
+    return DEFAULT_REGISTRY.copy()
+
+
+def save_registry(registry: list[dict[str, Any]]) -> None:
+    with open(MARKETPLACE_FILE, "w", encoding="utf-8") as f:
+        json.dump(registry, f, indent=2, ensure_ascii=False)
+
+
+def get_plugin_by_id(plugin_id: str) -> dict[str, Any] | None:
+    for p in load_registry():
+        if p["id"] == plugin_id:
+            return p
+    return None
+
+
+def install_plugin(plugin_id: str) -> dict[str, Any] | None:
+    registry = load_registry()
+    for p in registry:
+        if p["id"] == plugin_id:
+            p["installed"] = True
+            p["downloads"] = p.get("downloads", 0) + 1
+            save_registry(registry)
+            return p
+    return None
+
+
+def uninstall_plugin(plugin_id: str) -> dict[str, Any] | None:
+    registry = load_registry()
+    for p in registry:
+        if p["id"] == plugin_id:
+            p["installed"] = False
+            save_registry(registry)
+            return p
+    return None
+
+
+def search_plugins(query: str = "", tag: str = "") -> list[dict[str, Any]]:
+    results = load_registry()
+    if query:
+        q = query.lower()
+        results = [p for p in results if q in p["name"].lower() or q in p["description"].lower()]
+    if tag:
+        results = [p for p in results if tag in p.get("tags", [])]
+    return results
+
+
+def get_stats() -> dict[str, Any]:
+    registry = load_registry()
+    return {
+        "total_plugins": len(registry),
+        "installed": sum(1 for p in registry if p["installed"]),
+        "total_downloads": sum(p.get("downloads", 0) for p in registry),
+        "categories": list(set(t for p in registry for t in p.get("tags", []))),
+    }
+
+
+if __name__ == "__main__":
+    print("🛒 Dulus Plugin Marketplace v0.1")
+    print("=" * 40)
+    for p in load_registry():
+        status = "✅" if p["installed"] else "⬜"
+        print(f"{status} {p['name']} v{p['version']} — {p['description'][:50]}...")
+    print(f"\nStats: {json.dumps(get_stats(), indent=2)}")