memorytalk 0.4.0__py3-none-any.whl

memorytalk/__main__.py

@@ -0,0 +1,4 @@
+from memorytalk.cli import main
+
+if __name__ == "__main__":
+    main()

memorytalk/adapters/__init__.py

@@ -0,0 +1,4 @@
+"""Platform adapters for CLI `sync`."""
+from memorytalk.adapters.base import BaseAdapter, ADAPTERS, get_adapter, register  # noqa: F401
+# Importing concrete adapters triggers @register side effects.
+from memorytalk.adapters import claude_code  # noqa: F401

memorytalk/adapters/base.py

@@ -0,0 +1,33 @@
+"""Base adapter interface for CLI `sync`."""
+from __future__ import annotations
+from abc import ABC, abstractmethod
+from pathlib import Path
+from typing import Iterator
+
+
+class BaseAdapter(ABC):
+    """Adapter for a source platform (claude-code / codex / ...).
+
+    `iter_sessions(root)` yields ingest payloads — dicts with the shape of
+    POST /v2/sessions body, including a computed sha256 for content hashing.
+    """
+
+    source_name: str
+
+    @abstractmethod
+    def iter_sessions(self, root: Path | None = None) -> Iterator[dict]: ...
+
+
+ADAPTERS: dict[str, type[BaseAdapter]] = {}
+
+
+def register(cls: type[BaseAdapter]) -> type[BaseAdapter]:
+    ADAPTERS[cls.source_name] = cls
+    return cls
+
+
+def get_adapter(name: str) -> BaseAdapter:
+    cls = ADAPTERS.get(name)
+    if not cls:
+        raise ValueError(f"unknown adapter: {name}")
+    return cls()

memorytalk/adapters/claude_code.py

@@ -0,0 +1,119 @@
+"""Claude Code adapter — reads ~/.claude/projects/*.jsonl conversation files
+and produces POST /v2/sessions payloads.
+
+Porting note: v1 produced Session model objects; v2 wants the HTTP request
+body shape (raw platform session_id, dict rounds, sha256 over source bytes).
+"""
+from __future__ import annotations
+import hashlib
+import json
+from pathlib import Path
+from typing import Iterator
+from urllib.parse import unquote
+
+from memorytalk.adapters.base import BaseAdapter, register
+
+
+@register
+class ClaudeCodeAdapter(BaseAdapter):
+    source_name = "claude-code"
+
+    DEFAULT_ROOT = Path.home() / ".claude" / "projects"
+
+    def iter_sessions(self, root: Path | None = None) -> Iterator[dict]:
+        d = Path(root) if root else self.DEFAULT_ROOT
+        if not d.exists():
+            return
+        for path in sorted(d.rglob("*.jsonl")):
+            payload = self._convert_file(path)
+            if payload:
+                yield payload
+
+    def _convert_file(self, path: Path) -> dict | None:
+        raw_bytes = path.read_bytes()
+        sha256 = hashlib.sha256(raw_bytes).hexdigest()
+        session_id = path.stem  # raw platform id, no sess_ prefix
+        project_dir = path.parent.name
+        project_name = unquote(project_dir)
+
+        rounds: list[dict] = []
+        created_at: str | None = None
+        for line in raw_bytes.decode("utf-8", errors="replace").splitlines():
+            line = line.strip()
+            if not line:
+                continue
+            try:
+                msg = json.loads(line)
+            except json.JSONDecodeError:
+                continue
+            r = self._parse_message(msg)
+            if r is None:
+                continue
+            rounds.append(r)
+            if created_at is None and r.get("timestamp"):
+                created_at = r["timestamp"]
+
+        if not rounds:
+            return None
+
+        return {
+            "session_id": session_id,
+            "source": self.source_name,
+            "created_at": created_at or "",
+            "metadata": {"project": project_name, "path": str(path)},
+            "sha256": sha256,
+            "rounds": rounds,
+        }
+
+    def _parse_message(self, msg: dict) -> dict | None:
+        msg_type = msg.get("type")
+        if msg_type not in ("user", "assistant"):
+            return None
+        role = "human" if msg_type == "user" else "assistant"
+        speaker = "user" if msg_type == "user" else "assistant"
+        raw_content = msg.get("message", {}).get("content", [])
+        blocks = self._parse_content(raw_content)
+        if not blocks:
+            if isinstance(raw_content, str):
+                blocks = [{"type": "text", "text": raw_content}]
+            else:
+                return None
+        return {
+            "round_id": msg.get("uuid", ""),
+            "parent_id": msg.get("parentUuid"),
+            "timestamp": msg.get("timestamp"),
+            "speaker": speaker,
+            "role": role,
+            "content": blocks,
+            "is_sidechain": bool(msg.get("isSidechain")),
+            "cwd": msg.get("cwd"),
+        }
+
+    def _parse_content(self, content_list) -> list[dict]:
+        if not isinstance(content_list, list):
+            return []
+        out: list[dict] = []
+        for block in content_list:
+            if not isinstance(block, dict):
+                continue
+            t = block.get("type")
+            if t == "text":
+                text = block.get("text") or ""
+                if text:
+                    out.append({"type": "text", "text": text})
+            elif t == "thinking":
+                thinking = block.get("thinking") or ""
+                if thinking:
+                    out.append({"type": "thinking", "thinking": thinking})
+            elif t == "tool_use":
+                name = block.get("name", "tool")
+                inp = block.get("input", "")
+                if isinstance(inp, dict):
+                    inp = json.dumps(inp, ensure_ascii=False)
+                out.append({"type": "text", "text": f"[{name}] {inp}"})
+            elif t == "tool_result":
+                c = block.get("content", "")
+                if isinstance(c, list):
+                    c = json.dumps(c, ensure_ascii=False)
+                out.append({"type": "text", "text": str(c)})
+        return out

memorytalk/api/__init__.py

@@ -0,0 +1,100 @@
+"""FastAPI app factory for v2 — async setup via lifespan."""
+from __future__ import annotations
+import os
+import sys
+from contextlib import asynccontextmanager
+
+from fastapi import FastAPI, Request
+from fastapi.responses import JSONResponse
+
+from memorytalk.config import Config, ConfigValidationError
+from memorytalk.provider.embedding import (
+    EmbedderValidationError,
+    get_embedder,
+    validate_embedder,
+)
+from memorytalk.service import (
+    CardService, EventWriter, LinkService, RebuildService,
+    SearchService, SessionService,
+)
+from memorytalk.provider.lancedb import LanceStore
+from memorytalk.provider.storage import LocalStorage
+from memorytalk.repository import SQLiteStore
+
+
+def create_app(config: Config | None = None) -> FastAPI:
+    config = config or Config()
+    try:
+        config.validate()
+    except ConfigValidationError as e:
+        print(f"[memory-talk] config validation failed: {e}", file=sys.stderr)
+        raise SystemExit(2) from e
+
+    config.ensure_dirs()
+
+    @asynccontextmanager
+    async def lifespan(app: FastAPI):
+        # Async startup — open DB, LanceDB, probe embedding, wire services.
+        storage = LocalStorage(config.data_root)
+        db = await SQLiteStore.create(config.db_path, storage)
+        vectors = await LanceStore.create(config.vectors_dir, dim=config.settings.embedding.dim)
+        embedder = get_embedder(config)
+        events = EventWriter(db)
+
+        try:
+            await validate_embedder(config)
+        except EmbedderValidationError as e:
+            print(f"[memory-talk] embedding startup check failed: {e}", file=sys.stderr)
+            raise SystemExit(2) from e
+
+        app.state.config = config
+        app.state.storage = storage
+        app.state.db = db
+        app.state.vectors = vectors
+        app.state.embedder = embedder
+        app.state.sessions = SessionService(
+            config=config, db=db, vectors=vectors, events=events,
+        )
+        app.state.cards = CardService(
+            config=config, db=db, vectors=vectors, embedder=embedder, events=events,
+        )
+        app.state.links = LinkService(config=config, db=db, events=events)
+        app.state.search = SearchService(
+            config=config, db=db, vectors=vectors, embedder=embedder,
+        )
+        app.state.rebuild = RebuildService(
+            config=config, db=db, vectors=vectors, embedder=embedder,
+        )
+
+        yield
+
+        await db.close()
+
+    app = FastAPI(title="memory.talk v2", lifespan=lifespan)
+    app.state.config = config
+    app.state.status = "running"
+
+    @app.middleware("http")
+    async def rebuild_gate(request: Request, call_next):
+        status = getattr(request.app.state, "status", "running")
+        if status == "running":
+            return await call_next(request)
+        if request.method == "GET" and request.url.path == "/v2/status":
+            return await call_next(request)
+        return JSONResponse({"error": "rebuilding"}, status_code=503)
+
+    from memorytalk.api.status import router as status_router
+    app.include_router(status_router, prefix="/v2")
+
+    for name in ("sessions", "cards", "links", "tags", "search", "view", "log", "rebuild"):
+        try:
+            mod = __import__(f"memorytalk.api.{name}", fromlist=["router"])
+            app.include_router(mod.router, prefix="/v2")
+        except ImportError:
+            pass
+
+    return app
+
+
+_data_root = os.environ.get("MEMORY_TALK_DATA_ROOT")
+app = create_app(Config(_data_root) if _data_root else Config())

memorytalk/api/cards.py

@@ -0,0 +1,20 @@
+"""POST /v2/cards."""
+from __future__ import annotations
+
+from fastapi import APIRouter, HTTPException, Request
+
+from memorytalk.schemas import CreateCardRequest, CreateCardResponse
+from memorytalk.service import CardConflictError, CardServiceError
+
+
+router = APIRouter()
+
+
+@router.post("/cards", response_model=CreateCardResponse)
+async def post_cards(payload: CreateCardRequest, request: Request):
+    try:
+        return await request.app.state.cards.create(payload)
+    except CardConflictError as e:
+        raise HTTPException(status_code=409, detail=str(e))
+    except CardServiceError as e:
+        raise HTTPException(status_code=400, detail=str(e))

memorytalk/api/links.py

@@ -0,0 +1,20 @@
+"""POST /v2/links."""
+from __future__ import annotations
+
+from fastapi import APIRouter, HTTPException, Request
+
+from memorytalk.schemas import CreateLinkRequest, CreateLinkResponse
+from memorytalk.service import LinkNotFoundError, LinkServiceError
+
+
+router = APIRouter()
+
+
+@router.post("/links", response_model=CreateLinkResponse)
+async def post_links(payload: CreateLinkRequest, request: Request):
+    try:
+        return await request.app.state.links.create(payload)
+    except LinkNotFoundError as e:
+        raise HTTPException(status_code=404, detail=str(e))
+    except LinkServiceError as e:
+        raise HTTPException(status_code=400, detail=str(e))

memorytalk/api/log.py

@@ -0,0 +1,33 @@
+"""POST /v2/log — prefix-dispatched event stream."""
+from __future__ import annotations
+
+from fastapi import APIRouter, HTTPException, Request
+
+from memorytalk.util.ids import IdKind, InvalidIdError, parse_id
+from memorytalk.schemas import LogRequest, LogResponse
+from memorytalk.service import (
+    CardNotFound, CardServiceError, SessionNotFound, SessionServiceError,
+)
+
+
+router = APIRouter()
+
+
+@router.post("/log", response_model=LogResponse)
+async def post_log(payload: LogRequest, request: Request):
+    try:
+        kind, _ = parse_id(payload.id)
+    except InvalidIdError:
+        raise HTTPException(status_code=400, detail="invalid id prefix")
+
+    try:
+        if kind == IdKind.CARD:
+            return await request.app.state.cards.log(payload.id)
+        if kind == IdKind.SESSION:
+            return await request.app.state.sessions.log(payload.id)
+    except (CardNotFound, SessionNotFound) as e:
+        raise HTTPException(status_code=404, detail=str(e))
+    except (CardServiceError, SessionServiceError) as e:
+        raise HTTPException(status_code=400, detail=str(e))
+
+    raise HTTPException(status_code=400, detail="invalid id prefix")

memorytalk/api/rebuild.py

@@ -0,0 +1,21 @@
+"""POST /v2/rebuild."""
+from __future__ import annotations
+
+from fastapi import APIRouter, HTTPException, Request
+
+from memorytalk.schemas import RebuildResponse
+
+
+router = APIRouter()
+
+
+@router.post("/rebuild", response_model=RebuildResponse)
+async def post_rebuild(request: Request):
+    app = request.app
+    if getattr(app.state, "status", "running") != "running":
+        raise HTTPException(status_code=409, detail="rebuild already in progress")
+    app.state.status = "rebuilding"
+    try:
+        return await app.state.rebuild.rebuild()
+    finally:
+        app.state.status = "running"

memorytalk/api/search.py

@@ -0,0 +1,18 @@
+"""POST /v2/search."""
+from __future__ import annotations
+
+from fastapi import APIRouter, HTTPException, Request
+
+from memorytalk.schemas import SearchRequest, SearchResponse
+from memorytalk.service import SearchError
+
+
+router = APIRouter()
+
+
+@router.post("/search", response_model=SearchResponse)
+async def post_search(payload: SearchRequest, request: Request):
+    try:
+        return await request.app.state.search.search(payload)
+    except SearchError as e:
+        raise HTTPException(status_code=400, detail=str(e))

memorytalk/api/sessions.py

@@ -0,0 +1,18 @@
+"""POST /v2/sessions — ingest."""
+from __future__ import annotations
+
+from fastapi import APIRouter, HTTPException, Request
+
+from memorytalk.schemas import IngestSessionRequest, IngestSessionResponse
+from memorytalk.service import SessionServiceError
+
+
+router = APIRouter()
+
+
+@router.post("/sessions", response_model=IngestSessionResponse)
+async def post_sessions(payload: IngestSessionRequest, request: Request):
+    try:
+        return await request.app.state.sessions.ingest(payload)
+    except SessionServiceError as e:
+        raise HTTPException(status_code=400, detail=str(e))

memorytalk/api/status.py

@@ -0,0 +1,25 @@
+"""GET /v2/status — stats and running info."""
+from __future__ import annotations
+from fastapi import APIRouter, Request
+
+from memorytalk.schemas import StatusResponse
+
+router = APIRouter()
+
+
+@router.get("/status", response_model=StatusResponse)
+async def get_status(request: Request) -> StatusResponse:
+    config = request.app.state.config
+    db = request.app.state.db
+    return StatusResponse(
+        data_root=str(config.data_root),
+        settings_path=str(config.settings_path),
+        status=getattr(request.app.state, "status", "running"),
+        sessions_total=await db.sessions.count(),
+        cards_total=await db.cards.count(),
+        links_total=await db.links.count(),
+        searches_total=await db.search_log.count(),
+        vector_provider=config.settings.vector.provider,
+        relation_provider=config.settings.relation.provider,
+        embedding_provider=config.settings.embedding.provider,
+    )

memorytalk/api/tags.py

@@ -0,0 +1,30 @@
+"""POST /v2/tags/{add,remove}."""
+from __future__ import annotations
+
+from fastapi import APIRouter, HTTPException, Request
+
+from memorytalk.schemas import TagsRequest, TagsResponse
+from memorytalk.service import SessionNotFound, SessionServiceError
+
+
+router = APIRouter()
+
+
+@router.post("/tags/add", response_model=TagsResponse)
+async def post_tags_add(payload: TagsRequest, request: Request):
+    try:
+        return await request.app.state.sessions.add_tags(payload)
+    except SessionNotFound as e:
+        raise HTTPException(status_code=404, detail=str(e))
+    except SessionServiceError as e:
+        raise HTTPException(status_code=400, detail=str(e))
+
+
+@router.post("/tags/remove", response_model=TagsResponse)
+async def post_tags_remove(payload: TagsRequest, request: Request):
+    try:
+        return await request.app.state.sessions.remove_tags(payload)
+    except SessionNotFound as e:
+        raise HTTPException(status_code=404, detail=str(e))
+    except SessionServiceError as e:
+        raise HTTPException(status_code=400, detail=str(e))

memorytalk/api/view.py

@@ -0,0 +1,33 @@
+"""POST /v2/view — prefix-dispatched read."""
+from __future__ import annotations
+
+from fastapi import APIRouter, HTTPException, Request
+
+from memorytalk.util.ids import IdKind, InvalidIdError, parse_id
+from memorytalk.schemas import ViewRequest, ViewResponse
+from memorytalk.service import (
+    CardNotFound, CardServiceError, SessionNotFound, SessionServiceError,
+)
+
+
+router = APIRouter()
+
+
+@router.post("/view", response_model=ViewResponse)
+async def post_view(payload: ViewRequest, request: Request):
+    try:
+        kind, _ = parse_id(payload.id)
+    except InvalidIdError:
+        raise HTTPException(status_code=400, detail="invalid id prefix")
+
+    try:
+        if kind == IdKind.CARD:
+            return await request.app.state.cards.view(payload.id)
+        if kind == IdKind.SESSION:
+            return await request.app.state.sessions.view(payload.id)
+    except (CardNotFound, SessionNotFound) as e:
+        raise HTTPException(status_code=404, detail=str(e))
+    except (CardServiceError, SessionServiceError) as e:
+        raise HTTPException(status_code=400, detail=str(e))
+
+    raise HTTPException(status_code=400, detail="invalid id prefix")

memorytalk/cli/__init__.py

@@ -0,0 +1,21 @@
+"""memory-talk v2 CLI root."""
+from __future__ import annotations
+import click
+
+from memorytalk.cli.server import server
+
+
+@click.group()
+def main() -> None:
+    """memory-talk v2."""
+
+
+main.add_command(server)
+
+# Other command groups are attached as they're implemented.
+for _name in ("card", "tag", "link", "sync", "search", "view", "log", "rebuild", "setup"):
+    try:
+        _mod = __import__(f"memorytalk.cli.{_name}", fromlist=[_name])
+        main.add_command(getattr(_mod, _name))
+    except ImportError:
+        pass