devmemory 0.1.0__py3-none-any.whl

devmemory/commands/status.py

@@ -0,0 +1,71 @@
+import pathlib
+
+from rich.console import Console
+from rich.table import Table
+
+from devmemory.core.config import DevMemoryConfig
+from devmemory.core.sync_state import SyncState
+from devmemory.core.git_ai_parser import get_repo_root, get_git_ai_version, is_git_ai_installed
+from devmemory.core.ams_client import AMSClient
+from devmemory import __version__
+
+console = Console()
+
+
+def run_status():
+    config = DevMemoryConfig.load()
+
+    table = Table(title="DevMemory Status", show_header=False, border_style="dim")
+    table.add_column("Key", style="bold")
+    table.add_column("Value")
+
+    table.add_row("DevMemory version", __version__)
+
+    git_ai_ok = is_git_ai_installed()
+    git_ai_ver = get_git_ai_version() if git_ai_ok else "not installed"
+    table.add_row("Git AI", f"[green]{git_ai_ver}[/green]" if git_ai_ok else "[red]not installed[/red]")
+
+    repo_root = get_repo_root()
+    table.add_row("Git repo", repo_root or "[red]not in a git repo[/red]")
+
+    client = AMSClient(base_url=config.ams_endpoint)
+    try:
+        health = client.health_check()
+        ams_status = f"[green]healthy[/green] (endpoint: {config.ams_endpoint})"
+    except Exception:
+        health = None
+        ams_status = f"[red]unreachable[/red] (endpoint: {config.ams_endpoint})"
+    table.add_row("AMS server", ams_status)
+
+    if health:
+        count = client.get_memory_count(namespace=config.namespace)
+        table.add_row("Memories stored", str(count) if count >= 0 else "[yellow]unknown[/yellow]")
+    else:
+        table.add_row("Memories stored", "[dim]N/A[/dim]")
+
+    table.add_row("Namespace", config.namespace)
+    table.add_row("User ID", config.user_id or "[dim]auto (from git)[/dim]")
+
+    if repo_root:
+        state = SyncState.load(repo_root)
+        if state.last_synced_sha:
+            table.add_row("Last synced commit", state.last_synced_sha[:12])
+            table.add_row("Last synced at", state.last_synced_at)
+            table.add_row("Total synced", str(state.total_synced))
+        else:
+            table.add_row("Sync state", "[yellow]never synced[/yellow]")
+
+    if repo_root:
+        hook_path = pathlib.Path(repo_root) / ".git" / "hooks" / "post-commit"
+        if hook_path.exists() and "devmemory" in hook_path.read_text():
+            table.add_row("Post-commit hook", "[green]installed[/green]")
+        else:
+            table.add_row("Post-commit hook", "[yellow]not installed[/yellow] (run: devmemory install)")
+
+    mcp_config = pathlib.Path.home() / ".cursor" / "mcp.json"
+    if mcp_config.exists() and "agent-memory" in mcp_config.read_text():
+        table.add_row("Cursor MCP config", "[green]configured[/green]")
+    else:
+        table.add_row("Cursor MCP config", "[yellow]not configured[/yellow] (run: devmemory install)")
+
+    console.print(table)

devmemory/commands/sync.py

@@ -0,0 +1,125 @@
+import typer
+from rich.console import Console
+from rich.table import Table
+
+from devmemory.core.config import DevMemoryConfig
+from devmemory.core.sync_state import SyncState
+from devmemory.core.git_ai_parser import (
+    get_repo_root,
+    get_ai_notes_since,
+    get_latest_commit_note,
+)
+from devmemory.core.memory_formatter import format_commit_as_memories, format_commit_without_ai
+from devmemory.core.ams_client import AMSClient
+
+console = Console()
+
+
+def run_sync(
+    latest: bool = False,
+    all_commits: bool = False,
+    ai_only: bool = True,
+    dry_run: bool = False,
+    limit: int = 50,
+    quiet: bool = False,
+):
+    repo_root = get_repo_root()
+    if not repo_root:
+        if not quiet:
+            console.print("[red]Not inside a git repository.[/red]")
+        raise typer.Exit(1)
+
+    config = DevMemoryConfig.load()
+    state = SyncState.load(repo_root)
+
+    if latest:
+        note = get_latest_commit_note()
+        if not note:
+            if not quiet:
+                console.print("[yellow]No commits found.[/yellow]")
+            raise typer.Exit(0)
+        notes = [note]
+    else:
+        since_sha = None if all_commits else (state.last_synced_sha or None)
+        notes = get_ai_notes_since(since_sha, limit=limit)
+
+    if not notes:
+        if not quiet:
+            console.print("[green]Already up to date. No new commits to sync.[/green]")
+        raise typer.Exit(0)
+
+    if ai_only:
+        ai_notes = [n for n in notes if n.has_ai_note]
+        skipped = len(notes) - len(ai_notes)
+        if skipped > 0 and not quiet:
+            console.print(f"[dim]Skipping {skipped} commit(s) without AI notes.[/dim]")
+        notes_to_sync = ai_notes
+    else:
+        notes_to_sync = notes
+
+    if not notes_to_sync:
+        if not quiet:
+            console.print("[green]No commits with AI notes to sync.[/green]")
+        if notes:
+            state.mark_synced(notes[0].sha, count=0)
+        raise typer.Exit(0)
+
+    if not quiet:
+        table = Table(title=f"Commits to sync ({len(notes_to_sync)})")
+        table.add_column("SHA", style="cyan", width=12)
+        table.add_column("Subject", style="white")
+        table.add_column("AI Files", style="green", justify="right")
+        table.add_column("Prompts", style="magenta", justify="right")
+        table.add_column("Author", style="dim")
+
+        for n in notes_to_sync:
+            table.add_row(
+                n.sha[:12],
+                n.subject[:60],
+                str(len(n.files)),
+                str(len(n.prompts)),
+                n.author_name,
+            )
+        console.print(table)
+
+    if dry_run:
+        if not quiet:
+            console.print("[yellow]Dry run -- no memories sent.[/yellow]")
+        raise typer.Exit(0)
+
+    client = AMSClient(base_url=config.ams_endpoint)
+
+    try:
+        client.health_check()
+    except Exception as e:
+        if not quiet:
+            console.print(f"[red]Cannot reach AMS at {config.ams_endpoint}: {e}[/red]")
+            console.print("[dim]Is the Docker stack running? Try: make up[/dim]")
+        raise typer.Exit(1)
+
+    total_memories = 0
+    for n in notes_to_sync:
+        if n.has_ai_note:
+            memories = format_commit_as_memories(n, namespace=config.namespace, user_id=config.user_id)
+        else:
+            memories = format_commit_without_ai(n, namespace=config.namespace, user_id=config.user_id)
+
+        if memories:
+            try:
+                client.create_memories(memories)
+                total_memories += len(memories)
+                if not quiet:
+                    console.print(f"  [green]✓[/green] {n.sha[:12]} → {len(memories)} memory(s)")
+            except Exception as e:
+                if not quiet:
+                    console.print(f"  [red]✗[/red] {n.sha[:12]} → error: {e}")
+
+    newest_sha = notes_to_sync[0].sha
+    state.mark_synced(newest_sha, count=total_memories)
+
+    if quiet:
+        if total_memories > 0:
+            print(f"devmemory: synced {total_memories} memory(s) from {len(notes_to_sync)} commit(s)")
+    else:
+        console.print(f"\n[green]Synced {total_memories} memories from {len(notes_to_sync)} commit(s).[/green]")
+        console.print(f"[dim]Last synced: {newest_sha[:12]}[/dim]")

devmemory/core/__init__.py

@@ -0,0 +1 @@
+

devmemory/core/ams_client.py

@@ -0,0 +1,113 @@
+from __future__ import annotations
+
+import httpx
+from dataclasses import dataclass
+
+
+@dataclass
+class MemoryResult:
+    id: str
+    text: str
+    score: float
+    topics: list[str]
+    entities: list[str]
+    memory_type: str
+    created_at: str
+
+
+class AMSClient:
+    def __init__(self, base_url: str = "http://localhost:8000", timeout: float = 30.0):
+        self.base_url = base_url.rstrip("/")
+        self.timeout = timeout
+
+    def _client(self) -> httpx.Client:
+        return httpx.Client(base_url=self.base_url, timeout=self.timeout)
+
+    def health_check(self) -> dict:
+        with self._client() as client:
+            resp = client.get("/v1/health")
+            resp.raise_for_status()
+            return resp.json()
+
+    def create_memories(
+        self,
+        memories: list[dict],
+        deduplicate: bool = True,
+    ) -> dict:
+        payload = {
+            "memories": memories,
+            "deduplicate": deduplicate,
+        }
+        with self._client() as client:
+            resp = client.post("/v1/long-term-memory/", json=payload)
+            resp.raise_for_status()
+            return resp.json()
+
+    def search_memories(
+        self,
+        text: str,
+        limit: int = 10,
+        namespace: str | None = None,
+        user_id: str | None = None,
+        topics: list[str] | None = None,
+        memory_type: str | None = None,
+    ) -> list[MemoryResult]:
+        payload: dict = {
+            "text": text,
+            "limit": limit,
+        }
+        if namespace:
+            payload["namespace"] = {"eq": namespace}
+        if user_id:
+            payload["user_id"] = {"eq": user_id}
+        if topics:
+            payload["topics"] = {"any": topics}
+        if memory_type:
+            payload["memory_type"] = {"eq": memory_type}
+
+        with self._client() as client:
+            resp = client.post("/v1/long-term-memory/search", json=payload)
+            resp.raise_for_status()
+            data = resp.json()
+
+        results = []
+        for m in data.get("memories", []):
+            results.append(MemoryResult(
+                id=m.get("id", ""),
+                text=m.get("text", ""),
+                score=m.get("dist", 0.0),
+                topics=m.get("topics") or [],
+                entities=m.get("entities") or [],
+                memory_type=m.get("memory_type", ""),
+                created_at=m.get("created_at", ""),
+            ))
+        return results
+
+    def get_memory_count(self, namespace: str | None = None) -> int:
+        try:
+            total = 0
+            offset = 0
+            with self._client() as client:
+                while True:
+                    payload: dict = {"text": "", "limit": 100, "offset": offset}
+                    if namespace:
+                        payload["namespace"] = {"eq": namespace}
+                    resp = client.post("/v1/long-term-memory/search", json=payload)
+                    resp.raise_for_status()
+                    data = resp.json()
+                    total += len(data.get("memories", []))
+                    if data.get("next_offset") is None:
+                        break
+                    offset = data["next_offset"]
+            return total
+        except Exception:
+            return -1
+
+    def list_sessions(self, namespace: str | None = None, limit: int = 50) -> list[str]:
+        params: dict = {"limit": limit}
+        if namespace:
+            params["namespace"] = namespace
+        with self._client() as client:
+            resp = client.get("/v1/working-memory/", params=params)
+            resp.raise_for_status()
+            return resp.json().get("sessions", [])

devmemory/core/config.py

@@ -0,0 +1,42 @@
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from dataclasses import dataclass, field, asdict
+
+
+CONFIG_DIR = Path.home() / ".devmemory"
+CONFIG_FILE = CONFIG_DIR / "config.json"
+
+DEFAULTS = {
+    "ams_endpoint": "http://localhost:8000",
+    "mcp_endpoint": "http://localhost:9050",
+    "namespace": "default",
+    "user_id": "",
+}
+
+
+@dataclass
+class DevMemoryConfig:
+    ams_endpoint: str = DEFAULTS["ams_endpoint"]
+    mcp_endpoint: str = DEFAULTS["mcp_endpoint"]
+    namespace: str = DEFAULTS["namespace"]
+    user_id: str = DEFAULTS["user_id"]
+
+    @classmethod
+    def load(cls) -> DevMemoryConfig:
+        if CONFIG_FILE.exists():
+            raw = json.loads(CONFIG_FILE.read_text())
+            merged = {**DEFAULTS, **raw}
+            return cls(**{k: v for k, v in merged.items() if k in cls.__dataclass_fields__})
+        return cls()
+
+    def save(self) -> None:
+        CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+        CONFIG_FILE.write_text(json.dumps(asdict(self), indent=2) + "\n")
+
+    def set_value(self, key: str, value: str) -> None:
+        if key not in self.__dataclass_fields__:
+            raise KeyError(f"Unknown config key: {key}. Valid keys: {list(self.__dataclass_fields__)}")
+        setattr(self, key, value)
+        self.save()