devobin 1.0.0__py3-none-any.whl

devobin/core/memory.py

@@ -0,0 +1,78 @@
+"""Memory manager - manages long-term memory across sessions."""
+
+from __future__ import annotations
+
+from devobin.storage.database import GlobalStorage, ProjectStorage
+
+
+class MemoryManager:
+    """Manages both global and project-specific memory."""
+
+    def __init__(self, project_name: str | None = None) -> None:
+        self._global = GlobalStorage()
+        self._project = ProjectStorage(project_name) if project_name else None
+
+    # ── Global Memory ─────────────────────────────────────────────
+
+    def add_global_memory(self, content: str, category: str = "preference") -> dict:
+        return self._global.add_memory(content, category)
+
+    def get_global_memories(self, category: str | None = None) -> list[dict]:
+        return self._global.get_memories(category)
+
+    def search_global_memories(self, query: str) -> list[dict]:
+        return self._global.search_memories(query)
+
+    # ── Project Memory ────────────────────────────────────────────
+
+    def add_project_memory(self, content: str, category: str = "general") -> dict | None:
+        if self._project:
+            return self._project.add_memory(content, category)
+        return None
+
+    def get_project_memories(self, category: str | None = None) -> list[dict]:
+        if self._project:
+            return self._project.get_memories(category)
+        return []
+
+    def search_project_memories(self, query: str) -> list[dict]:
+        if self._project:
+            return self._project.search_memories(query)
+        return []
+
+    # ── Combined Context ──────────────────────────────────────────
+
+    def get_memory_context(self) -> str:
+        """Build a formatted string of all relevant memory for AI context."""
+        lines: list[str] = []
+
+        global_prefs = self.get_global_memories("preference")
+        if global_prefs:
+            lines.append("**User Preferences:**")
+            for m in global_prefs[-10:]:  # Last 10 preferences
+                lines.append(f"- {m['content']}")
+
+        project_mem = self.get_project_memories()
+        if project_mem:
+            lines.append("\n**Project Context:**")
+            for m in project_mem[-10:]:
+                lines.append(f"- {m['content']}")
+
+        return "\n".join(lines)
+
+    # ── Convenience ───────────────────────────────────────────────
+
+    def remember(self, content: str, scope: str = "project", category: str = "general") -> dict | None:
+        """Remember something. scope: 'global' or 'project'."""
+        if scope == "global":
+            return self.add_global_memory(content, category)
+        return self.add_project_memory(content, category)
+
+    def recall(self, query: str, scope: str = "both") -> list[dict]:
+        """Recall memories matching query."""
+        results: list[dict] = []
+        if scope in ("global", "both"):
+            results.extend(self.search_global_memories(query))
+        if scope in ("project", "both") and self._project:
+            results.extend(self.search_project_memories(query))
+        return results

devobin/core/optimizer.py

@@ -0,0 +1,106 @@
+"""Token optimizer - compacts and optimizes prompts for minimal token usage."""
+
+from __future__ import annotations
+
+import re
+
+
+def optimize_prompt(text: str) -> str:
+    """Optimize a prompt for token efficiency while preserving meaning."""
+    lines = text.split("\n")
+    optimized: list[str] = []
+    prev_blank = False
+
+    for line in lines:
+        stripped = line.strip()
+
+        # Collapse multiple blank lines
+        if not stripped:
+            if not prev_blank:
+                optimized.append("")
+            prev_blank = True
+            continue
+
+        prev_blank = False
+
+        # Skip redundant phrases
+        if _is_redundant(stripped):
+            continue
+
+        # Compact verbose phrases
+        line = _compact_phrases(stripped)
+        optimized.append(line)
+
+    return "\n".join(optimized).strip()
+
+
+def _is_redundant(line: str) -> bool:
+    """Check if a line is redundant and can be removed."""
+    redundant_patterns = [
+        r"^(it is important to|it is essential to|make sure to|be sure to|don't forget to)\s",
+        r"^(please|kindly|ensure that you|remember to)\s",
+        r"^(always remember that|note that|keep in mind that)\s",
+    ]
+    for pattern in redundant_patterns:
+        if re.match(pattern, line, re.IGNORECASE):
+            return True
+    return False
+
+
+def _compact_phrases(text: str) -> str:
+    """Replace verbose phrases with concise equivalents."""
+    replacements = [
+        (r"in order to", "to"),
+        (r"for the purpose of", "for"),
+        (r"due to the fact that", "because"),
+        (r"at this point in time", "now"),
+        (r"in the event that", "if"),
+        (r"on a regular basis", "regularly"),
+        (r"with regard to", "regarding"),
+        (r"in the process of", "while"),
+        (r"has the ability to", "can"),
+        (r"is able to", "can"),
+    ]
+    for pattern, replacement in replacements:
+        text = re.sub(pattern, replacement, text, flags=re.IGNORECASE)
+    return text
+
+
+def estimate_tokens(text: str) -> int:
+    """Rough token count estimate (1 token ≈ 4 chars for English)."""
+    return len(text) // 4
+
+
+def compress_context(messages: list[dict[str, str]], max_tokens: int = 8000) -> list[dict[str, str]]:
+    """Compress chat context to fit within token budget."""
+    total = sum(estimate_tokens(m["content"]) for m in messages)
+
+    if total <= max_tokens:
+        return messages
+
+    # Keep the system message and recent messages
+    result: list[dict[str, str]] = []
+    budget = max_tokens
+
+    # Always keep first message if it's a system
+    if messages and messages[0]["role"] == "system":
+        system_msg = messages[0]
+        system_tokens = estimate_tokens(system_msg["content"])
+        result.append(system_msg)
+        budget -= system_tokens
+        messages = messages[1:]
+
+    # Keep recent messages, summarize old ones
+    kept: list[dict[str, str]] = []
+    for msg in reversed(messages):
+        msg_tokens = estimate_tokens(msg["content"])
+        if budget - msg_tokens >= 0:
+            kept.insert(0, msg)
+            budget -= msg_tokens
+        else:
+            break
+
+    if kept:
+        result.extend(kept)
+
+    return result