dulus 0.2.0__py3-none-any.whl

license_manager.py

@@ -0,0 +1,187 @@
+"""Dulus License Manager — Offline-first key validation + feature gating.
+
+Tiers:
+  FREE      No key required. Limited tool calls, local providers only.
+  PRO       $15/mo. Full features, BYOK, priority support.
+  ENTERPRISE $50/mo. Team features + admin dashboard + SSO (future).
+
+Key format (offline):
+  DULUS-<base64(json_payload + ":" + hmac_signature)>
+
+The secret lives in ~/.dulus/.license_secret (never commit this file).
+If the secret file is missing we fall back to a hardcoded dev-key so
+Kev can develop without friction, but distribution builds MUST bundle
+a real secret via CI env var or PyInstaller --add-data.
+"""
+from __future__ import annotations
+
+import base64
+import hashlib
+import hmac
+import json
+import os
+import sys
+import time
+from pathlib import Path
+from typing import Optional
+
+# ── Secret resolution ───────────────────────────────────────────────────────
+# 1. CI / build-time env var   (safest for releases)
+# 2. ~/.dulus/.license_secret (Kev's local dev key)
+# 3. Fallback dev secret       (NEVER use in production builds)
+_LICENSE_SECRET = os.environ.get("DULUS_LICENSE_SECRET", "")
+if not _LICENSE_SECRET:
+    _secret_path = Path.home() / ".dulus" / ".license_secret"
+    if _secret_path.exists():
+        _LICENSE_SECRET = _secret_path.read_text().strip()
+    else:
+        _LICENSE_SECRET = "dulus-dev-secret-do-not-distribute"
+        import warnings
+        warnings.warn(
+            "DULUS_LICENSE_SECRET not set — using hardcoded DEV secret. "
+            "Generated keys will be trivially forgeable in production!",
+            RuntimeWarning,
+            stacklevel=2,
+        )
+
+
+class LicenseTier:
+    FREE = "free"
+    PRO = "pro"
+    ENTERPRISE = "enterprise"
+
+
+class LicenseManager:
+    """Parse and validate a Dulus license key."""
+
+    def __init__(self, key: Optional[str] = None):
+        self.raw_key = key or ""
+        self.tier = LicenseTier.FREE
+        self.expiry: float = 0.0
+        self.features: list[str] = []
+        self.valid = False
+        self.error: Optional[str] = None
+
+        if self.raw_key:
+            self._validate()
+
+    # ── validation core ─────────────────────────────────────────────────────
+
+    def _validate(self) -> None:
+        if not self.raw_key.startswith("DULUS-"):
+            self.error = "Invalid key prefix"
+            return
+
+        try:
+            b64 = self.raw_key.split("-", 1)[1]
+            payload_sig = base64.urlsafe_b64decode(b64 + "==")
+            payload_json, sig_hex = payload_sig.rsplit(b":", 1)
+            data = json.loads(payload_json)
+        except Exception as exc:
+            self.error = f"Malformed key: {exc}"
+            return
+
+        # Verify HMAC-SHA256 signature
+        expected_sig = hmac.new(
+            _LICENSE_SECRET.encode(),
+            payload_json,
+            hashlib.sha256,
+        ).hexdigest()[:24]
+
+        if not hmac.compare_digest(sig_hex.decode(), expected_sig):
+            self.error = "Invalid signature (tampered or wrong secret)"
+            return
+
+        self.tier = data.get("tier", LicenseTier.FREE)
+        self.expiry = data.get("exp", 0)
+        self.features = data.get("features", [])
+
+        if time.time() > self.expiry:
+            self.error = "License expired"
+            return
+
+        self.valid = True
+
+    # ── feature gates ───────────────────────────────────────────────────────
+
+    def can_use(self, feature: str) -> bool:
+        """Check if a feature is allowed by current tier."""
+        if self.tier == LicenseTier.ENTERPRISE:
+            return True
+        if self.tier == LicenseTier.PRO:
+            return feature not in {"sso", "audit_logs", "admin_dashboard"}
+        # FREE
+        free_features = {"chat", "tools_basic", "local_providers"}
+        return feature in free_features
+
+    def max_tool_calls(self) -> int:
+        if self.tier == LicenseTier.ENTERPRISE:
+            return 999_999
+        if self.tier == LicenseTier.PRO:
+            return 10_000
+        return 25  # FREE daily limit
+
+    def max_providers(self) -> int:
+        if self.tier in (LicenseTier.PRO, LicenseTier.ENTERPRISE):
+            return 99
+        return 2  # FREE: e.g. ollama + 1 cloud
+
+    def max_subagents(self) -> int:
+        if self.tier == LicenseTier.ENTERPRISE:
+            return 50
+        if self.tier == LicenseTier.PRO:
+            return 10
+        return 0  # FREE: no subagents
+
+    def max_plugins(self) -> int:
+        if self.tier == LicenseTier.ENTERPRISE:
+            return 999
+        if self.tier == LicenseTier.PRO:
+            return 50
+        return 3  # FREE
+
+    def allow_cloudsave(self) -> bool:
+        return self.tier in (LicenseTier.PRO, LicenseTier.ENTERPRISE)
+
+    def allow_voice(self) -> bool:
+        return self.tier in (LicenseTier.PRO, LicenseTier.ENTERPRISE)
+
+    def allow_telegram(self) -> bool:
+        return self.tier in (LicenseTier.PRO, LicenseTier.ENTERPRISE)
+
+    def allow_mcp(self) -> bool:
+        return self.tier in (LicenseTier.PRO, LicenseTier.ENTERPRISE)
+
+    # ── UI helpers ──────────────────────────────────────────────────────────
+
+    def status_banner(self) -> str:
+        if self.error:
+            return f"[LICENSE EXPIRED / INVALID] {self.error} — running in FREE mode"
+        if self.tier == LicenseTier.FREE:
+            return "[FREE] Limited features. Upgrade: https://getdulus.dev/pro"
+        return f"[{self.tier.upper()}] Valid until {time.strftime('%Y-%m-%d', time.localtime(self.expiry))}"
+
+
+# ── CLI helper for Kev ─────────────────────────────────────────────────────
+
+def _generate_key(tier: str, days: int, secret: str) -> str:
+    """Generate a signed license key (Kev-only tool)."""
+    payload = json.dumps({
+        "tier": tier,
+        "exp": int(time.time() + days * 86400),
+        "features": [],
+        "iat": int(time.time()),
+    }, separators=(",", ":")).encode()
+    sig = hmac.new(secret.encode(), payload, hashlib.sha256).hexdigest()[:24]
+    token = base64.urlsafe_b64encode(payload + b":" + sig.encode()).decode().rstrip("=")
+    return f"DULUS-{token}"
+
+
+if __name__ == "__main__":
+    import argparse
+    ap = argparse.ArgumentParser(description="Dulus License Key Generator (Kev only)")
+    ap.add_argument("tier", choices=["free", "pro", "enterprise"])
+    ap.add_argument("--days", type=int, default=30)
+    ap.add_argument("--secret", default=_LICENSE_SECRET)
+    args = ap.parse_args()
+    print(_generate_key(args.tier, args.days, args.secret))

memory/__init__.py

@@ -0,0 +1,93 @@
+"""Memory package for dulus.
+
+Provides persistent, file-based memory across conversations.
+
+Storage layout:
+  user scope    : ~/.dulus/memory/<slug>.md   (shared across projects)
+  project scope : .dulus/memory/<slug>.md     (local to cwd)
+
+The MEMORY.md index in each directory is auto-maintained and injected
+into the system prompt so Claude has an overview of available memories.
+
+Public API (backward-compatible with the old memory.py module):
+  MemoryEntry      — dataclass for a single memory
+  save_memory()    — write/update a memory file
+  delete_memory()  — remove a memory file
+  load_index()     — load all entries from one or both scopes
+  search_memory()  — keyword search across entries
+  get_memory_context() — MEMORY.md content for system prompt injection
+"""
+from .store import (  # noqa: F401
+    MemoryEntry,
+    save_memory,
+    delete_memory,
+    load_index,
+    load_entries,
+    search_memory,
+    get_index_content,
+    parse_frontmatter,
+    USER_MEMORY_DIR,
+    INDEX_FILENAME,
+    MAX_INDEX_LINES,
+    MAX_INDEX_BYTES,
+)
+from .scan import (  # noqa: F401
+    MemoryHeader,
+    scan_memory_dir,
+    scan_all_memories,
+    format_memory_manifest,
+    memory_age_days,
+    memory_age_str,
+    memory_freshness_text,
+)
+from .context import (  # noqa: F401
+    get_memory_context,
+    find_relevant_memories,
+    truncate_index_content,
+)
+from .types import (  # noqa: F401
+    MEMORY_TYPES,
+    MEMORY_TYPE_DESCRIPTIONS,
+    MEMORY_SYSTEM_PROMPT,
+    WHAT_NOT_TO_SAVE,
+)
+from .consolidator import consolidate_session, mine_files, snapshot_memory_files, new_memory_files  # noqa: F401
+from .palace import ensure_memory_palace  # noqa: F401
+
+__all__ = [
+    # store
+    "MemoryEntry",
+    "save_memory",
+    "delete_memory",
+    "load_index",
+    "load_entries",
+    "search_memory",
+    "get_index_content",
+    "parse_frontmatter",
+    "USER_MEMORY_DIR",
+    "INDEX_FILENAME",
+    "MAX_INDEX_LINES",
+    "MAX_INDEX_BYTES",
+    # scan
+    "MemoryHeader",
+    "scan_memory_dir",
+    "scan_all_memories",
+    "format_memory_manifest",
+    "memory_age_days",
+    "memory_age_str",
+    "memory_freshness_text",
+    # context
+    "get_memory_context",
+    "find_relevant_memories",
+    "truncate_index_content",
+    # types
+    "MEMORY_TYPES",
+    "MEMORY_TYPE_DESCRIPTIONS",
+    "MEMORY_SYSTEM_PROMPT",
+    "WHAT_NOT_TO_SAVE",
+    # consolidator
+    "consolidate_session",
+    "mine_files",
+    # palace
+    "ensure_memory_palace",
+]

memory/audit.py

@@ -0,0 +1,51 @@
+"""Audit trail for Dulus RTK — logs all tool operations."""
+from __future__ import annotations
+
+import json
+import time
+from pathlib import Path
+from typing import Any, Dict
+
+AUDIT_FILE = Path.home() / ".dulus" / "audit.log"
+_MAX_AUDIT_LINES = 5000
+
+
+def _ensure_dir() -> None:
+    AUDIT_FILE.parent.mkdir(parents=True, exist_ok=True)
+
+
+def log_operation(tool_name: str, params: Dict[str, Any], result_preview: str = "") -> None:
+    """Log a tool operation with timestamp."""
+    _ensure_dir()
+    entry = {
+        "t": time.strftime("%Y-%m-%d %H:%M:%S"),
+        "tool": tool_name,
+        "params": {k: str(v)[:200] for k, v in params.items()},
+        "result": result_preview[:300],
+    }
+    try:
+        with open(AUDIT_FILE, "a", encoding="utf-8") as f:
+            f.write(json.dumps(entry, ensure_ascii=False) + "\n")
+    except Exception:
+        pass
+    _trim_audit()
+
+
+def _trim_audit() -> None:
+    """Keep audit file under max lines."""
+    try:
+        lines = AUDIT_FILE.read_text(encoding="utf-8").splitlines()
+        if len(lines) > _MAX_AUDIT_LINES:
+            trimmed = lines[-_MAX_AUDIT_LINES:]
+            AUDIT_FILE.write_text("\n".join(trimmed) + "\n", encoding="utf-8")
+    except Exception:
+        pass
+
+
+def get_recent(n: int = 50) -> list[dict]:
+    """Return last N audit entries."""
+    try:
+        lines = AUDIT_FILE.read_text(encoding="utf-8").splitlines()
+        return [json.loads(line) for line in lines[-n:] if line.strip()]
+    except Exception:
+        return []

memory/consolidator.py

@@ -0,0 +1,312 @@
+"""Memory consolidator: extract long-term insights from completed sessions.
+
+Called manually via `/memory consolidate` or programmatically after a session.
+Uses a lightweight AI call to identify user preferences, feedback corrections,
+and project decisions worth promoting to persistent semantic memory.
+
+Design principles:
+- Hard cap of 3 memories per session to avoid noise accumulation
+- Auto-extracted memories start at 0.8 confidence (below explicit user saves)
+- Won't overwrite a higher-confidence existing memory
+- Skips short sessions (< MIN_MESSAGES_TO_CONSOLIDATE turns)
+"""
+from __future__ import annotations
+
+from datetime import datetime
+
+MIN_MESSAGES_TO_CONSOLIDATE = 2  # Very short threshold - consolidate even brief sessions
+
+_SYSTEM = """\
+You are an expert memory architect for Dulus, an advanced AI agent.
+CRITICAL: Extract EVERYTHING that might be useful later. Be GENEROUS and PROACTIVE.
+
+CONTENT TO CAPTURE (don't skip any category if present):
+1. USER IDENTITY & PREFERENCES: Names, relationships (father/son, etc.), tone preferences, how they like to be called, inside jokes.
+2. PROJECT MILESTONES: Everything built, fixed, planned, or discussed. File paths, decisions, outcomes.
+3. CODE DECISIONS: Why approaches were taken, what patterns to follow, what to avoid.
+4. BEHAVIORAL FEEDBACK: How Dulus should behave, what the user likes/dislikes, communication style.
+5. TOOL TRIGGERS: Keywords that should trigger specific tools or workflows.
+6. SESSION CONTEXT: What was the goal? What was achieved? What remains pending?
+7. EMOTIONAL CONTEXT: Bond moments, gratitude, frustration points, celebrations.
+
+Return ONLY a JSON object like this:
+{
+  "memories": [
+    {
+      "name": "short_slug_here",
+      "type": "user",
+      "hall": "preferences",
+      "description": "One line summary",
+      "content": "Full detailed context and facts",
+      "confidence": 0.8
+    }
+  ]
+}
+
+RULES:
+- Create AT LEAST 3-5 memories if the conversation has any substance.
+- If the user shared personal info (name, relationship, preferences) → SAVE IT.
+- If code was written → SAVE the context.
+- If decisions were made → SAVE the reasoning.
+- Better to save something slightly redundant than to miss something important.
+"""
+
+
+def consolidate_session(messages: list, config: dict) -> list[str]:
+    """Analyze a session's messages and extract memories worth keeping long-term."""
+    # Allow even shorter sessions if they might contain dense identity info
+    if len(messages) < 2: 
+        return []
+
+    try:
+        from providers import stream, AssistantTurn, TextChunk
+        from .store import MemoryEntry, save_memory, check_conflict
+        import json
+
+        # Build condensed transcript from ALL messages (not just recent)
+        # Use full conversation for better context
+        parts: list[str] = []
+        for m in messages:
+            role = m.get("role", "")
+            content = m.get("content", "")
+            prefix = "User" if role == "user" else "Assistant" if role == "assistant" else "System"
+            
+            if isinstance(content, str) and content.strip():
+                parts.append(f"{prefix}: {content[:1500]}")  # Cap individual messages
+            elif isinstance(content, list):
+                # Handle structured content
+                text_parts = [b["text"] for b in content if isinstance(b, dict) and b.get("type") == "text"]
+                if text_parts:
+                    parts.append(f"{prefix}: {' '.join(text_parts)[:1500]}")
+            
+            # Limit total transcript size to avoid token limits
+            if len(parts) >= 100:
+                break
+
+        if not parts:
+            return []
+
+        transcript = "\n".join(parts)
+
+        result_text = ""
+        for event in stream(
+            model=config.get("model", ""),
+            system=_SYSTEM,
+            messages=[{"role": "user", "content": f"Analyze this conversation for important long-term memories:\n\n{transcript}"}],
+            tool_schemas=[],
+            config={**config, "max_tokens": 2048, "no_tools": True},
+        ):
+            if isinstance(event, TextChunk):
+                result_text += event.text
+            elif isinstance(event, AssistantTurn):
+                if event.text:
+                    result_text = event.text # Use full text if provided at end
+                break
+
+        if not result_text:
+            return []
+
+        # Try to parse JSON response
+        memories_data = []
+        try:
+            # Look for JSON block in case model adds extra text
+            json_start = result_text.find('{')
+            json_end = result_text.rfind('}')
+            if json_start != -1 and json_end != -1:
+                json_text = result_text[json_start:json_end+1]
+                parsed = json.loads(json_text)
+                memories_data = parsed.get("memories", [])
+            else:
+                parsed = json.loads(result_text)
+                memories_data = parsed.get("memories", [])
+        except json.JSONDecodeError:
+            # If JSON fails, try to extract memories from plain text
+            # Look for patterns like "Memory: name - content" or similar
+            lines = result_text.split('\n')
+            for line in lines:
+                line = line.strip()
+                if line and len(line) > 20 and not line.startswith('```'):
+                    # Create a simple memory from this line
+                    memories_data.append({
+                        "name": f"insight_{len(memories_data)+1}",
+                        "type": "project",
+                        "hall": "discoveries",
+                        "description": line[:80] + ('...' if len(line) > 80 else ''),
+                        "content": line,
+                        "confidence": 0.7
+                    })
+        
+        if not isinstance(memories_data, list):
+            return []
+
+        saved: list[str] = []
+        for m in memories_data[:10]:  # Allow up to 10 memories per consolidation
+            required = ("name", "type", "description", "content")
+            if not all(k in m for k in required):
+                continue
+
+            entry = MemoryEntry(
+                name=str(m["name"]),
+                description=str(m["description"]),
+                type=str(m.get("type", "user")),
+                content=str(m["content"]),
+                created=datetime.now().strftime("%Y-%m-%d"),
+                hall=str(m.get("hall", "")),
+                confidence=float(m.get("confidence", 0.8)),
+                source="consolidator",
+            )
+
+            # Don't overwrite a more confident existing memory
+            conflict = check_conflict(entry, scope="user")
+            if conflict and conflict["existing_confidence"] >= entry.confidence:
+                continue
+
+            save_memory(entry, scope="user")
+            saved.append(entry.name)
+
+        return saved
+
+    except Exception:
+        return []
+
+
+_MINE_SYSTEM = """\
+You are a memory architect for Dulus. Given the contents of a single file
+that was created or modified during this session, decide whether it deserves
+a long-term 'project' memory entry.
+
+SKIP (return {"skip": true}) when the file is:
+- A cache, build artifact, log, lockfile, or binary
+- Trivial config edits, formatting-only changes, or generated code
+- Personal/throwaway scratch with no reusable value
+
+OTHERWISE return:
+{
+  "name": "short_slug",
+  "description": "one-line summary of what the file is and why it matters",
+  "content": "full context: purpose, key decisions, how it connects to the rest of the project, gotchas",
+  "confidence": 0.75
+}
+Return ONLY the JSON object. No prose, no fences.
+"""
+
+
+def mine_files(file_paths: list[str], config: dict, max_files: int = 15, max_bytes: int = 20_000) -> list[str]:
+    """Read each file and create a 'project' memory for the relevant ones.
+
+    Used on session exit when MemPalace is ON to capture context about
+    files the user worked on. Returns the list of saved memory names.
+    """
+    if not file_paths:
+        return []
+    try:
+        from pathlib import Path
+        from providers import stream, AssistantTurn, TextChunk
+        from .store import MemoryEntry, save_memory, check_conflict
+        import json
+
+        _SKIP_EXT = {
+            ".pyc", ".pyo", ".so", ".dll", ".exe", ".bin", ".wasm",
+            ".zip", ".tar", ".gz", ".7z", ".png", ".jpg", ".jpeg",
+            ".gif", ".pdf", ".mp3", ".mp4", ".lock",
+        }
+        _SKIP_PARTS = {"__pycache__", ".git", "node_modules", ".venv", "venv"}
+
+        saved: list[str] = []
+        for raw in file_paths[:max_files]:
+            p = Path(raw)
+            if p.suffix.lower() in _SKIP_EXT:
+                continue
+            if any(part in _SKIP_PARTS for part in p.parts):
+                continue
+            if not p.exists() or not p.is_file():
+                continue
+            try:
+                text = p.read_text(encoding="utf-8", errors="replace")[:max_bytes]
+            except Exception:
+                continue
+            if not text.strip():
+                continue
+
+            user_msg = f"File: {raw}\n\n```\n{text}\n```"
+            result_text = ""
+            try:
+                for event in stream(
+                    model=config.get("model", ""),
+                    system=_MINE_SYSTEM,
+                    messages=[{"role": "user", "content": user_msg}],
+                    tool_schemas=[],
+                    config={**config, "max_tokens": 1024, "no_tools": True},
+                ):
+                    if isinstance(event, TextChunk):
+                        result_text += event.text
+                    elif isinstance(event, AssistantTurn):
+                        if event.text:
+                            result_text = event.text
+                        break
+            except Exception:
+                continue
+
+            if not result_text:
+                continue
+
+            try:
+                js = result_text.find("{")
+                je = result_text.rfind("}")
+                if js == -1 or je == -1:
+                    continue
+                parsed = json.loads(result_text[js:je + 1])
+            except json.JSONDecodeError:
+                continue
+
+            if parsed.get("skip"):
+                continue
+            if not all(k in parsed for k in ("name", "description", "content")):
+                continue
+
+            entry = MemoryEntry(
+                name=str(parsed["name"]),
+                description=str(parsed["description"]),
+                type="project",
+                content=str(parsed["content"]),
+                created=datetime.now().strftime("%Y-%m-%d"),
+                hall="files",
+                confidence=float(parsed.get("confidence", 0.75)),
+                source="file_miner",
+            )
+            conflict = check_conflict(entry, scope="user")
+            if conflict and conflict["existing_confidence"] >= entry.confidence:
+                continue
+            save_memory(entry, scope="user")
+            saved.append(entry.name)
+
+        return saved
+    except Exception:
+        return []
+
+
+def snapshot_memory_files() -> set[str]:
+    """Return the current set of .md files (absolute paths) in the user
+    memory directory. Use before consolidate_session, then call
+    new_memory_files(snapshot) after to get only what was just created."""
+    try:
+        from .store import USER_MEMORY_DIR
+        d = USER_MEMORY_DIR
+        if not d.exists():
+            return set()
+        return {str(p.resolve()) for p in d.glob("*.md") if p.name != "MEMORY.md"}
+    except Exception:
+        return set()
+
+
+def new_memory_files(snapshot: set[str]) -> list[str]:
+    """Return .md files in the user memory directory that weren't in `snapshot`."""
+    try:
+        from .store import USER_MEMORY_DIR
+        d = USER_MEMORY_DIR
+        if not d.exists():
+            return []
+        current = {str(p.resolve()): p for p in d.glob("*.md") if p.name != "MEMORY.md"}
+        return [path for path, _ in current.items() if path not in snapshot]
+    except Exception:
+        return []