dev-recall 0.2.0__py3-none-any.whl

recall/mcp_server.py

@@ -0,0 +1,290 @@
+"""MCP server — exposes Recall tools via the Model Context Protocol (stdio)."""
+
+from __future__ import annotations
+
+import logging
+from datetime import datetime, timezone
+from typing import Any, Optional
+
+from mcp.server.fastmcp import FastMCP
+
+logger = logging.getLogger(__name__)
+
+mcp = FastMCP("dev-recall")
+
+
+# ---------------------------------------------------------------------------
+# Tool: recall
+# ---------------------------------------------------------------------------
+
+
+@mcp.tool()
+def recall(query: str, days: int = 7, top_k: int = 10) -> str:
+    """
+    Search developer activity history by natural language query.
+
+    Returns relevant events: terminal commands, git commits, file edits, AI chats.
+
+    Args:
+        query: Natural language query about past work
+        days: How many days back to search (default 7)
+        top_k: Number of results to return (default 10)
+    """
+    try:
+        from recall.config import load_config
+        from recall.storage.db import DB
+        from recall.storage.vectors import VectorStore
+        from recall.processor.embedder import EmbedderQueue
+        from recall.query.retriever import Retriever
+        from recall.query.timeparser import to_iso
+
+        config = load_config()
+        if not config.db_path.exists():
+            return "Recall database not found. Run: recall init"
+
+        now = datetime.now(timezone.utc)
+        from datetime import timedelta
+        start = now - timedelta(days=days)
+        date_range = (start, now)
+
+        db = DB(config.db_path)
+        vectors = VectorStore.from_file(config.faiss_path, dim=config.embedding_dim)
+        embedder = EmbedderQueue(db=db, vectors=vectors, model_name=config.embedding_model)
+        retriever = Retriever(db=db, vectors=vectors, embedder=embedder)
+
+        events = retriever.search(query, top_k=top_k, date_range=date_range)
+        db.close()
+
+        if not events:
+            return f"No activity found matching '{query}' in the last {days} days."
+
+        lines = [f"Found {len(events)} relevant activities:\n"]
+        for i, event in enumerate(events, 1):
+            ts = _fmt_ts(event.timestamp)
+            lines.append(f"{i}. [{ts}] {event.content}")
+
+        return "\n".join(lines)
+
+    except Exception as exc:
+        logger.exception("recall tool error")
+        return f"Error: {exc}"
+
+
+# ---------------------------------------------------------------------------
+# Tool: today_summary
+# ---------------------------------------------------------------------------
+
+
+@mcp.tool()
+def today_summary() -> str:
+    """
+    Get a summary of what the developer worked on today.
+    """
+    try:
+        from recall.config import load_config
+        from recall.storage.db import DB
+        from recall.query.llm import is_available, ask as llm_ask, DevMemLLMError, configure
+        from recall.query.context import build_prompt_summary
+
+        config = load_config()
+        if not config.db_path.exists():
+            return "Recall database not found. Run: recall init"
+
+        configure(model=config.llm_model)
+        db = DB(config.db_path)
+        date_str = datetime.now(timezone.utc).strftime("%Y-%m-%d")
+        events = db.get_events_by_date(date_str)
+
+        if not events:
+            db.close()
+            return "No activity recorded today yet."
+
+        # Check cached summary
+        cached = db.get_daily_summary(date_str)
+        if cached and cached.get("summary"):
+            db.close()
+            return cached["summary"]
+
+        if not is_available():
+            db.close()
+            lines = [f"Today's activity ({date_str}, {len(events)} events):\n"]
+            for e in events[:20]:
+                lines.append(f"• {e.content}")
+            return "\n".join(lines)
+
+        messages = build_prompt_summary(date_str, events)
+        summary = llm_ask(messages)
+        db.close()
+        return summary
+
+    except Exception as exc:
+        logger.exception("today_summary tool error")
+        return f"Error: {exc}"
+
+
+# ---------------------------------------------------------------------------
+# Tool: recent_repos
+# ---------------------------------------------------------------------------
+
+
+@mcp.tool()
+def recent_repos(days: int = 7) -> str:
+    """
+    List repositories the developer was active in recently.
+
+    Args:
+        days: How many days back to look (default 7)
+    """
+    try:
+        from recall.config import load_config
+        from recall.storage.db import DB
+        from datetime import timedelta
+
+        config = load_config()
+        if not config.db_path.exists():
+            return "Recall database not found. Run: recall init"
+
+        db = DB(config.db_path)
+        now = datetime.now(timezone.utc)
+        start = (now - timedelta(days=days)).strftime("%Y-%m-%dT%H:%M:%SZ")
+        end = now.strftime("%Y-%m-%dT%H:%M:%SZ")
+
+        events = db.get_events_by_date_range(start, end)
+        db.close()
+
+        repo_activity: dict[str, int] = {}
+        for e in events:
+            if e.repo_name:
+                repo_activity[e.repo_name] = repo_activity.get(e.repo_name, 0) + 1
+
+        if not repo_activity:
+            return f"No repository activity in the last {days} days."
+
+        lines = [f"Active repositories (last {days} days):\n"]
+        for repo, count in sorted(repo_activity.items(), key=lambda x: -x[1]):
+            lines.append(f"• {repo}  ({count} events)")
+        return "\n".join(lines)
+
+    except Exception as exc:
+        logger.exception("recent_repos tool error")
+        return f"Error: {exc}"
+
+
+# ---------------------------------------------------------------------------
+# Tool: find_command
+# ---------------------------------------------------------------------------
+
+
+@mcp.tool()
+def find_command(description: str, repo: Optional[str] = None) -> str:
+    """
+    Find a terminal command previously run, by describing what it does.
+
+    Args:
+        description: Natural language description of what the command does
+        repo: Optional: limit search to a specific repo name
+    """
+    try:
+        from recall.config import load_config
+        from recall.storage.db import DB
+        from recall.storage.vectors import VectorStore
+        from recall.processor.embedder import EmbedderQueue
+        from recall.query.retriever import Retriever
+        from recall.models import EventType
+
+        config = load_config()
+        if not config.db_path.exists():
+            return "Recall database not found. Run: recall init"
+
+        db = DB(config.db_path)
+        vectors = VectorStore.from_file(config.faiss_path, dim=config.embedding_dim)
+        embedder = EmbedderQueue(db=db, vectors=vectors, model_name=config.embedding_model)
+        retriever = Retriever(db=db, vectors=vectors, embedder=embedder)
+
+        events = retriever.search(
+            description,
+            top_k=10,
+            event_types=[EventType.TERMINAL_CMD],
+            repo_name=repo,
+        )
+        db.close()
+
+        if not events:
+            return f"No matching commands found for: '{description}'"
+
+        lines = [f"Commands matching '{description}':\n"]
+        for i, event in enumerate(events, 1):
+            ts = _fmt_ts(event.timestamp)
+            cmd = event.raw_data.get("cmd", event.content)
+            lines.append(f"{i}. [{ts}] {cmd}")
+
+        return "\n".join(lines)
+
+    except Exception as exc:
+        logger.exception("find_command tool error")
+        return f"Error: {exc}"
+
+
+# ---------------------------------------------------------------------------
+# Tool: timeline
+# ---------------------------------------------------------------------------
+
+
+@mcp.tool()
+def timeline(date: Optional[str] = None) -> str:
+    """
+    Get chronological activity log for a specific date.
+
+    Args:
+        date: Date in YYYY-MM-DD format. Defaults to today.
+    """
+    try:
+        from recall.config import load_config
+        from recall.storage.db import DB
+
+        config = load_config()
+        if not config.db_path.exists():
+            return "Recall database not found. Run: recall init"
+
+        db = DB(config.db_path)
+        date_str = date or datetime.now(timezone.utc).strftime("%Y-%m-%d")
+        events = db.get_events_by_date(date_str)
+        db.close()
+
+        if not events:
+            return f"No activity recorded on {date_str}."
+
+        lines = [f"Timeline for {date_str} ({len(events)} events):\n"]
+        for event in events:
+            ts = _fmt_ts(event.timestamp)
+            lines.append(f"[{ts}] {event.event_type.value}: {event.content}")
+
+        return "\n".join(lines)
+
+    except Exception as exc:
+        logger.exception("timeline tool error")
+        return f"Error: {exc}"
+
+
+# ---------------------------------------------------------------------------
+# Entry point
+# ---------------------------------------------------------------------------
+
+
+def run_mcp_server() -> None:
+    """Run the MCP server on stdio."""
+    logging.basicConfig(level=logging.WARNING)
+    mcp.run(transport="stdio")
+
+
+# ---------------------------------------------------------------------------
+# Helpers
+# ---------------------------------------------------------------------------
+
+
+def _fmt_ts(ts_str: str) -> str:
+    try:
+        dt = datetime.fromisoformat(ts_str.replace("Z", "+00:00"))
+        return dt.astimezone().strftime("%Y-%m-%d %H:%M")
+    except ValueError:
+        return ts_str[:16]

recall/models.py

@@ -0,0 +1,225 @@
+"""DevMem data models — Event dataclass and enums."""
+
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass, field
+from enum import Enum
+from typing import Any, Optional
+
+
+class EventType(str, Enum):
+    TERMINAL_CMD = "terminal_cmd"
+    GIT_COMMIT = "git_commit"
+    GIT_BRANCH = "git_branch_switch"
+    GIT_PUSH = "git_push"
+    GIT_MERGE = "git_merge"
+    FILE_SAVE = "file_save"
+    FILE_CREATE = "file_create"
+    FILE_DELETE = "file_delete"
+    FILE_RENAME = "file_rename"
+    REPO_OPEN = "repo_open"
+    REPO_CLOSE = "repo_close"
+    AI_CHAT = "ai_chat"
+    DEBUG_SESSION = "debug_session"
+    TEST_RUN = "test_run"
+
+
+class Source(str, Enum):
+    SHELL_HOOK = "shell_hook"
+    GIT_HOOK = "git_hook"
+    GIT_POLLER = "git_poller"
+    VSCODE_EXT = "vscode_ext"
+    AI_CHAT_PARSER = "ai_chat_parser"
+
+
+@dataclass
+class Event:
+    """A single captured developer activity event."""
+
+    timestamp: str  # ISO 8601 UTC, e.g. "2026-05-21T14:30:00Z"
+    date: str  # YYYY-MM-DD derived from timestamp
+    event_type: EventType
+    source: Source
+    content: str  # Human-readable text used for embedding & display
+    raw_data: dict[str, Any]  # Original parsed data
+    metadata: dict[str, Any] = field(default_factory=dict)
+    repo_path: Optional[str] = None  # Canonical absolute path
+    repo_name: Optional[str] = None  # Basename
+    session_id: Optional[str] = None  # UUID
+    embedding_id: Optional[int] = None
+    id: Optional[int] = None  # Set after DB insert
+
+    # ------------------------------------------------------------------
+    # Serialization helpers
+    # ------------------------------------------------------------------
+
+    def to_db_row(self) -> dict[str, Any]:
+        """Return a dict suitable for inserting into the SQLite events table."""
+        return {
+            "timestamp": self.timestamp,
+            "date": self.date,
+            "event_type": self.event_type.value,
+            "source": self.source.value,
+            "content": self.content,
+            "raw_data": json.dumps(self.raw_data),
+            "metadata": json.dumps(self.metadata),
+            "repo_path": self.repo_path,
+            "repo_name": self.repo_name,
+            "session_id": self.session_id,
+            "embedding_id": self.embedding_id,
+        }
+
+    @classmethod
+    def from_db_row(cls, row: dict[str, Any]) -> "Event":
+        """Reconstruct an Event from a SQLite row dict."""
+        return cls(
+            id=row["id"],
+            timestamp=row["timestamp"],
+            date=row["date"],
+            event_type=EventType(row["event_type"]),
+            source=Source(row["source"]),
+            content=row["content"],
+            raw_data=json.loads(row["raw_data"]) if row["raw_data"] else {},
+            metadata=json.loads(row["metadata"]) if row["metadata"] else {},
+            repo_path=row.get("repo_path"),
+            repo_name=row.get("repo_name"),
+            session_id=row.get("session_id"),
+            embedding_id=row.get("embedding_id"),
+        )
+
+    def to_dict(self) -> dict[str, Any]:
+        """Return a JSON-serializable dict."""
+        return {
+            "id": self.id,
+            "timestamp": self.timestamp,
+            "date": self.date,
+            "event_type": self.event_type.value,
+            "source": self.source.value,
+            "content": self.content,
+            "raw_data": self.raw_data,
+            "metadata": self.metadata,
+            "repo_path": self.repo_path,
+            "repo_name": self.repo_name,
+            "session_id": self.session_id,
+            "embedding_id": self.embedding_id,
+        }
+
+
+# ---------------------------------------------------------------------------
+# Content text builders
+# ---------------------------------------------------------------------------
+
+
+def build_content(event_type: EventType, data: dict[str, Any]) -> str:
+    """Build the human-readable content string for an event from its raw data.
+
+    This is the text used for both display and embedding.
+    """
+    match event_type:
+        case EventType.TERMINAL_CMD:
+            cmd = data.get("cmd", "")
+            repo = data.get("repo_name") or _basename(data.get("cwd", ""))
+            exit_code = data.get("exit_code", 0)
+            duration = data.get("duration_ms", 0)
+            return f"[terminal] {cmd} in {repo} (exit {exit_code}, {duration}ms)"
+
+        case EventType.GIT_COMMIT:
+            message = data.get("message", "")
+            branch = data.get("branch", "")
+            repo = data.get("repo_name", "")
+            files = data.get("files", [])
+            files_str = ", ".join(files[:5]) if files else ""
+            if len(files) > 5:
+                files_str += f" (+{len(files) - 5} more)"
+            return f"[git] commit '{message}' to {branch} in {repo}. Changed: {files_str}"
+
+        case EventType.GIT_BRANCH:
+            new_branch = data.get("new_branch", "")
+            old_branch = data.get("old_branch", "")
+            repo = data.get("repo_name", "")
+            return f"[git] switched to branch '{new_branch}' in {repo} (from '{old_branch}')"
+
+        case EventType.GIT_PUSH:
+            repo = data.get("repo_name", "")
+            branch = data.get("branch", "")
+            remote = data.get("remote", "origin")
+            count = data.get("commit_count", 0)
+            return f"[git] pushed {count} commit(s) on {branch} to {remote} in {repo}"
+
+        case EventType.GIT_MERGE:
+            repo = data.get("repo_name", "")
+            branch = data.get("branch", "")
+            merged = data.get("merged_branch", "")
+            squash = data.get("is_squash", False)
+            merge_type = "squash-merged" if squash else "merged"
+            merged_str = f" '{merged}'" if merged else ""
+            return f"[git] {merge_type}{merged_str} into {branch} in {repo}"
+
+        case EventType.FILE_SAVE:
+            filename = data.get("filename", "")
+            language = data.get("language", "")
+            repo = data.get("repo_name", "")
+            return f"[edit] saved {filename} ({language}) in {repo}"
+
+        case EventType.FILE_CREATE:
+            filename = data.get("filename", "")
+            repo = data.get("repo_name", "")
+            return f"[edit] created {filename} in {repo}"
+
+        case EventType.FILE_DELETE:
+            filename = data.get("filename", "")
+            repo = data.get("repo_name", "")
+            return f"[edit] deleted {filename} in {repo}"
+
+        case EventType.FILE_RENAME:
+            old = data.get("old_filename", "")
+            new = data.get("new_filename", "")
+            repo = data.get("repo_name", "")
+            return f"[edit] renamed {old} -> {new} in {repo}"
+
+        case EventType.REPO_OPEN:
+            repo = data.get("repo_name", "")
+            path = data.get("repo_path", "")
+            return f"[workspace] opened {repo} ({path})"
+
+        case EventType.REPO_CLOSE:
+            repo = data.get("repo_name", "")
+            duration = data.get("duration_minutes", 0)
+            return f"[workspace] closed {repo} after {duration} minutes"
+
+        case EventType.AI_CHAT:
+            source = data.get("ai_source", "ai")
+            role = data.get("role", "user")
+            preview = data.get("message_preview", "")[:150]
+            repo = data.get("repo_name", "")
+            suffix = f" in {repo}" if repo else ""
+            return f"[{source} chat] {role}: {preview}{suffix}"
+
+        case EventType.DEBUG_SESSION:
+            name = data.get("name", "")
+            repo = data.get("repo_name", "")
+            action = data.get("action", "started")
+            debug_type = data.get("debug_type", "")
+            type_str = f" ({debug_type})" if debug_type else ""
+            return f"[debug] {action} session '{name}'{type_str} in {repo}"
+
+        case EventType.TEST_RUN:
+            name = data.get("name", "")
+            repo = data.get("repo_name", "")
+            action = data.get("action", "started")
+            exit_code = data.get("exit_code")
+            if action == "finished" and exit_code is not None:
+                status = "passed" if exit_code == 0 else "failed"
+                return f"[test] '{name}' {status} in {repo}"
+            return f"[test] {action} '{name}' in {repo}"
+
+        case _:
+            return str(data)
+
+
+def _basename(path: str) -> str:
+    """Return the last component of a path string."""
+    import os
+
+    return os.path.basename(path.rstrip("/")) or path

recall/processor/__init__.py

@@ -0,0 +1 @@
+"""Processor package."""