dulus 0.2.0__py3-none-any.whl

memory/sessions.py

@@ -0,0 +1,100 @@
+"""Historical session search utility."""
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from datetime import datetime
+from config import DAILY_DIR, SESSION_HIST_FILE
+
+def search_session_history(query: str, max_results: int = 5) -> list[dict]:
+    """Search for a query string across historical session logs.
+    
+    Checks both history.json (master) and daily/ copier directories.
+    Returns list of hits: {session_id, saved_at, hits: [{role, content_snippet}]}.
+    """
+    query = query.lower()
+    all_sessions = []
+
+    # 1. Load history.json (master file)
+    if SESSION_HIST_FILE.exists():
+        try:
+            data = json.loads(SESSION_HIST_FILE.read_text(encoding="utf-8", errors="replace"))
+            all_sessions.extend(data.get("sessions", []))
+        except Exception:
+            pass
+    
+    # WSL Fallback: If in WSL and history is empty, check Windows home host
+    import sys
+    if not all_sessions and sys.platform == "linux" and Path("/mnt/c").exists():
+        # Heuristic: try common Windows user paths
+        # This is a bit of a hack but helpful for users running in WSL
+        # who didn't symlink their .dulus folder yet.
+        try:
+            # Try to find a .dulus directory in any user folder on C:
+            c_users = Path("/mnt/c/Users")
+            for udir in c_users.iterdir():
+                if not udir.is_dir(): continue
+                win_hist = udir / ".dulus" / "sessions" / "history.json"
+                if win_hist.exists():
+                    data = json.loads(win_hist.read_text(encoding="utf-8", errors="replace"))
+                    all_sessions.extend(data.get("sessions", []))
+                    break
+        except Exception:
+            pass
+
+    # 2. SUPPLEMENT: Scan daily folders for sessions not in history (if any)
+    # This ensures we don't miss the absolute latest if history.json wasn't written yet
+    known_ids = {s.get("session_id") for s in all_sessions if s.get("session_id")}
+    
+    if DAILY_DIR.exists():
+        for day_dir in sorted(DAILY_DIR.iterdir(), reverse=True):
+            if not day_dir.is_dir():
+                continue
+            for session_file in sorted(day_dir.glob("session_*.json"), reverse=True):
+                try:
+                    # Quick check: session ID is in filename session_HHMMSS_sid.json
+                    sid = session_file.stem.split("_")[-1]
+                    if sid in known_ids:
+                        continue
+                    
+                    s_data = json.loads(session_file.read_text(encoding="utf-8", errors="replace"))
+                    all_sessions.append(s_data)
+                except Exception:
+                    continue
+
+    # 3. Perform search
+    results = []
+    for sess in all_sessions:
+        session_id = sess.get("session_id", "unknown")
+        saved_at   = sess.get("saved_at", "unknown")
+        messages   = sess.get("messages", [])
+        
+        session_hits = []
+        for msg in messages:
+            content = msg.get("content", "")
+            if not isinstance(content, str):
+                continue
+                
+            if query in content.lower():
+                # Extract snippet
+                start = max(0, content.lower().find(query) - 60)
+                end   = min(len(content), start + 200)
+                snippet = content[start:end].replace("\n", " ")
+                if start > 0: snippet = "..." + snippet
+                if end < len(content): snippet += "..."
+                
+                session_hits.append({
+                    "role": msg.get("role"),
+                    "snippet": snippet
+                })
+        
+        if session_hits:
+            results.append({
+                "session_id": session_id,
+                "saved_at": saved_at,
+                "hits": session_hits[:3] # limit hits per session to avoid bloat
+            })
+
+    # Sort sessions by recency (newest hit first)
+    results.sort(key=lambda x: x["saved_at"], reverse=True)
+    return results[:max_results]

memory/store.py

@@ -0,0 +1,395 @@
+"""File-based memory storage with user-level and project-level scopes.
+
+Storage layout:
+  user scope    : ~/.dulus/memory/<slug>.md
+  project scope : .dulus/memory/<slug>.md  (relative to cwd)
+
+Search uses token-based fuzzy matching with field weighting
+(name 3×, description 2×, content 1×) for better recall than
+simple substring matching.
+
+MEMORY.md in each directory is the index file — rebuilt automatically after
+every save/delete. It is loaded into the system prompt to give Dulus an
+overview of available memories.
+"""
+from __future__ import annotations
+
+import difflib
+import re
+from dataclasses import dataclass
+from pathlib import Path
+
+
+# ── Paths ──────────────────────────────────────────────────────────────────
+
+USER_MEMORY_DIR = Path.home() / ".dulus" / "memory"
+INDEX_FILENAME = "MEMORY.md"
+
+# Maximum lines/bytes for the index file 
+MAX_INDEX_LINES = 200
+MAX_INDEX_BYTES = 25_000
+
+
+def get_project_memory_dir() -> Path:
+    """Return the project-local memory directory (relative to cwd)."""
+    return Path.cwd() / ".dulus-context" / "memory"
+
+
+def get_memory_dir(scope: str = "user") -> Path:
+    """Return the memory directory for the given scope.
+
+    Args:
+        scope: "user" (global ~/.dulus/memory) or
+               "project" (.dulus/memory relative to cwd)
+    """
+    if scope == "project":
+        return get_project_memory_dir()
+    return USER_MEMORY_DIR
+
+
+# ── Data model ─────────────────────────────────────────────────────────────
+
+@dataclass
+class MemoryEntry:
+    """A single memory entry loaded from a .md file.
+
+    Attributes:
+        name:           human-readable name (also the display title in the index)
+        description:    short one-line description (used for relevance decisions)
+        type:           "user" | "feedback" | "project" | "reference"
+        hall:           categorization — "facts" | "events" | "discoveries" |
+                        "preferences" | "advice" | "" (empty = uncategorized)
+        content:        body text of the memory
+        file_path:      absolute path to the .md file on disk
+        created:        date string, e.g. "2026-04-02"
+        scope:          "user" | "project" — which directory this was loaded from
+        confidence:     0.0–1.0 reliability score (default 1.0 = explicit user statement)
+        source:         origin: "user" | "model" | "tool" | "consolidator"
+        last_used_at:   ISO date of last retrieval (updated on MemorySearch hits)
+        conflict_group: tag linking related/conflicting memories (e.g. "writing_style")
+    """
+    name: str
+    description: str
+    type: str
+    content: str
+    file_path: str = ""
+    created: str = ""
+    scope: str = "user"
+    hall: str = ""
+    confidence: float = 1.0
+    source: str = "user"
+    last_used_at: str = ""
+    conflict_group: str = ""
+    gold: bool = False
+
+
+# ── Helpers ────────────────────────────────────────────────────────────────
+
+import unicodedata
+
+def _slugify(name: str) -> str:
+    """Convert name to a filesystem-safe slug (max 60 chars)."""
+    s = unicodedata.normalize('NFKD', name).encode('ascii', 'ignore').decode('ascii')
+    s = s.lower().strip().replace(" ", "_")
+    s = re.sub(r"[^a-z0-9_]", "", s)
+    return s[:60]
+
+
+def parse_frontmatter(text: str) -> tuple[dict, str]:
+    """Parse ---\\nkey: value\\n---\\nbody format.
+
+    Returns:
+        (meta_dict, body_str)
+    """
+    if not text.startswith("---"):
+        return {}, text
+    parts = text.split("---", 2)
+    if len(parts) < 3:
+        return {}, text
+    meta: dict = {}
+    for line in parts[1].strip().splitlines():
+        if ":" in line:
+            key, _, val = line.partition(":")
+            meta[key.strip()] = val.strip()
+    return meta, parts[2].strip()
+
+
+def _format_entry_md(entry: MemoryEntry) -> str:
+    """Render a MemoryEntry as a markdown file with YAML frontmatter."""
+    lines = [
+        "---",
+        f"name: {entry.name}",
+        f"description: {entry.description}",
+        f"type: {entry.type}",
+    ]
+    if entry.hall:
+        lines.append(f"hall: {entry.hall}")
+    lines.append(f"created: {entry.created}")
+    if entry.confidence != 1.0:
+        lines.append(f"confidence: {entry.confidence:.2f}")
+    if entry.source and entry.source != "user":
+        lines.append(f"source: {entry.source}")
+    if entry.last_used_at:
+        lines.append(f"last_used_at: {entry.last_used_at}")
+    if entry.conflict_group:
+        lines.append(f"conflict_group: {entry.conflict_group}")
+    if entry.gold:
+        lines.append("gold: true")
+    lines.append("---")
+    lines.append(entry.content)
+    return "\n".join(lines) + "\n"
+
+
+# ── Core storage operations ────────────────────────────────────────────────
+
+def save_memory(entry: MemoryEntry, scope: str = "user") -> None:
+    """Write/update a memory file and rebuild the index for that scope.
+
+    If a memory with the same name (slug) already exists, it is overwritten.
+
+    Args:
+        entry: MemoryEntry to persist
+        scope: "user" or "project"
+    """
+    mem_dir = get_memory_dir(scope)
+    mem_dir.mkdir(parents=True, exist_ok=True)
+    slug = _slugify(entry.name)
+    fp = mem_dir / f"{slug}.md"
+    fp.write_text(_format_entry_md(entry), encoding="utf-8")
+    entry.file_path = str(fp)
+    entry.scope = scope
+    _rewrite_index(scope)
+
+
+def delete_memory(name: str, scope: str = "user") -> None:
+    """Remove the memory file matching name and rebuild the index.
+
+    No error if not found.
+    """
+    mem_dir = get_memory_dir(scope)
+    slug = _slugify(name)
+    fp = mem_dir / f"{slug}.md"
+    if fp.exists():
+        fp.unlink()
+    _rewrite_index(scope)
+
+
+def load_entries(scope: str = "user") -> list[MemoryEntry]:
+    """Scan all .md files (except MEMORY.md) in a scope and return entries.
+
+    Returns:
+        List of MemoryEntry sorted alphabetically by name.
+    """
+    mem_dir = get_memory_dir(scope)
+    if not mem_dir.exists():
+        return []
+    entries: list[MemoryEntry] = []
+    for fp in sorted(mem_dir.glob("*.md")):
+        if fp.name == INDEX_FILENAME:
+            continue
+        try:
+            text = fp.read_text(encoding="utf-8", errors="replace")
+        except Exception:
+            continue
+        meta, body = parse_frontmatter(text)
+        entries.append(MemoryEntry(
+            name=meta.get("name", fp.stem),
+            description=meta.get("description", ""),
+            type=meta.get("type", "user"),
+            content=body,
+            file_path=str(fp),
+            created=meta.get("created", ""),
+            scope=scope,
+            hall=meta.get("hall", ""),
+            confidence=float(meta.get("confidence", 1.0)),
+            source=meta.get("source", "user"),
+            last_used_at=meta.get("last_used_at", ""),
+            conflict_group=meta.get("conflict_group", ""),
+            gold=meta.get("gold", "").lower() == "true",
+        ))
+    return entries
+
+
+def load_index(scope: str = "all") -> list[MemoryEntry]:
+    """Load memory entries from one or both scopes.
+
+    Args:
+        scope: "user", "project", or "all" (both combined)
+
+    Returns:
+        List of MemoryEntry (user entries first, then project).
+    """
+    if scope == "all":
+        return load_entries("user") + load_entries("project")
+    return load_entries(scope)
+
+
+def _tokenize(text: str) -> list[str]:
+    """Split text into lowercase tokens (words)."""
+    import re
+    return re.findall(r'[a-záéíóúñü0-9_]+', text.lower())
+
+
+def _token_score(query_tokens: list[str], text: str) -> float:
+    """Score how well query tokens match a text field.
+
+    For each query token, find the best match among text tokens using
+    SequenceMatcher (handles typos, partial matches, synonyms-by-prefix).
+    Returns average best-match ratio (0.0–1.0).
+    """
+    from difflib import SequenceMatcher
+    if not query_tokens or not text:
+        return 0.0
+    text_tokens = _tokenize(text)
+    if not text_tokens:
+        return 0.0
+
+    total = 0.0
+    for qt in query_tokens:
+        best = 0.0
+        for tt in text_tokens:
+            # Exact substring match = perfect score
+            if qt in tt or tt in qt:
+                best = 1.0
+                break
+            ratio = SequenceMatcher(None, qt, tt).ratio()
+            if ratio > best:
+                best = ratio
+        total += best
+    return total / len(query_tokens)
+
+
+def search_memory(
+    query: str,
+    scope: str = "all",
+    hall: str = "",
+    min_score: float = 0.35,
+) -> list[MemoryEntry]:
+    """Token-based fuzzy search on name + description + content.
+
+    Scores each memory using weighted field matching:
+      name × 3.0 + description × 2.0 + content × 1.0
+
+    Args:
+        query:     search query string
+        scope:     "user", "project", or "all"
+        hall:      optional hall filter ("facts", "events", etc.)
+        min_score: minimum relevance score to include (0.0–1.0)
+
+    Returns:
+        List of (MemoryEntry, score) tuples sorted by score descending.
+        For backward compat, if called without unpacking, entries are
+        accessible directly (score attached as _search_score attribute).
+    """
+    query_tokens = _tokenize(query)
+
+    # Empty query with hall filter = list all in that hall
+    if not query_tokens:
+        if hall:
+            results = [e for e in load_index(scope) if e.hall == hall]
+            for e in results:
+                e._search_score = 1.0  # type: ignore[attr-defined]
+            return results
+        return []
+
+    scored: list[tuple[MemoryEntry, float]] = []
+    for entry in load_index(scope):
+        # Hall filter
+        if hall and entry.hall != hall:
+            continue
+
+        # Weighted field scoring
+        name_score = _token_score(query_tokens, entry.name)
+        desc_score = _token_score(query_tokens, entry.description)
+        body_score = _token_score(query_tokens, entry.content[:4000])
+
+        # Lower name weight (was 3.0) so short generic names like "soul" or
+        # "preferences" don't dominate every query just because they fuzzy-
+        # match a token. Body now gets a slightly bigger vote.
+        total = (name_score * 2.0 + desc_score * 2.0 + body_score * 1.5) / 5.5
+
+        if total >= min_score:
+            entry._search_score = total  # type: ignore[attr-defined]
+            scored.append((entry, total))
+
+    scored.sort(key=lambda x: x[1], reverse=True)
+    return [entry for entry, _ in scored]
+
+
+def _rewrite_index(scope: str) -> None:
+    """Rebuild MEMORY.md for the given scope from all .md files in that dir."""
+    mem_dir = get_memory_dir(scope)
+    if not mem_dir.exists():
+        return
+    index_path = mem_dir / INDEX_FILENAME
+    entries = load_entries(scope)
+    lines = [
+        f"- [{e.name}]({Path(e.file_path).name}) — {e.description}"
+        for e in entries
+    ]
+    index_path.write_text("\n".join(lines) + ("\n" if lines else ""), encoding="utf-8")
+
+
+def get_index_content(scope: str = "user") -> str:
+    """Return raw MEMORY.md content for the given scope, or '' if absent."""
+    mem_dir = get_memory_dir(scope)
+    index_path = mem_dir / INDEX_FILENAME
+    if not index_path.exists():
+        return ""
+    return index_path.read_text(encoding="utf-8", errors="replace").strip()
+
+
+def check_conflict(entry: "MemoryEntry", scope: str = "user") -> dict | None:
+    """Check whether a same-named memory already exists with different content.
+
+    Returns a dict with the existing memory's key fields if a conflict is found,
+    or None if no existing file or if the content is identical.
+    """
+    mem_dir = get_memory_dir(scope)
+    slug = _slugify(entry.name)
+    fp = mem_dir / f"{slug}.md"
+    if not fp.exists():
+        return None
+    try:
+        meta, existing_content = parse_frontmatter(fp.read_text(encoding="utf-8", errors="replace"))
+    except Exception:
+        return None
+    if existing_content.strip() == entry.content.strip():
+        return None
+    return {
+        "existing_content": existing_content.strip(),
+        "existing_confidence": float(meta.get("confidence", 1.0)),
+        "existing_created": meta.get("created", ""),
+        "existing_source": meta.get("source", "user"),
+    }
+
+
+def touch_last_used(file_path: str) -> None:
+    """Update the last_used_at frontmatter field of a memory file to today.
+
+    Called by MemorySearch when a memory is returned so staleness/utility
+    tracking stays current. Silent on any error.
+    """
+    from datetime import date
+    fp = Path(file_path)
+    if not fp.exists():
+        return
+    try:
+        text = fp.read_text(encoding="utf-8", errors="replace")
+        meta, body = parse_frontmatter(text)
+        today = date.today().isoformat()
+        if meta.get("last_used_at") == today:
+            return  # already up to date, skip the write
+        meta["last_used_at"] = today
+        # Rebuild frontmatter
+        fm_lines = ["---"]
+        for k in ("name", "description", "type", "hall", "created", "confidence",
+                   "source", "last_used_at", "conflict_group", "gold"):
+            v = meta.get(k)
+            if v is not None and str(v):
+                fm_lines.append(f"{k}: {v}")
+        fm_lines.append("---")
+        new_text = "\n".join(fm_lines) + "\n" + body + "\n"
+        fp.write_text(new_text, encoding="utf-8")
+    except Exception:
+        pass