@smilintux/skmemory 0.7.2 → 0.9.2

package/skmemory/importers/telegram.py

@@ -28,7 +28,6 @@ import json
 from collections import defaultdict
 from datetime import datetime, timezone
 from pathlib import Path
-from typing import Optional
 
 import click
 
@@ -118,8 +117,27 @@ def _detect_emotion(text: str) -> EmotionalSnapshot:
     if text.isupper() and len(text) > 10:
         intensity = min(intensity + 2.0, 10.0)
 
-    love_emojis = {"\u2764", "\U0001f495", "\U0001f496", "\U0001f497", "\U0001f498", "\U0001f49d", "\U0001f970", "\U0001f60d", "\U0001f49e"}
-    joy_emojis = {"\U0001f602", "\U0001f923", "\U0001f604", "\U0001f60a", "\U0001f389", "\U0001f973", "\u2728", "\U0001f38a"}
+    love_emojis = {
+        "\u2764",
+        "\U0001f495",
+        "\U0001f496",
+        "\U0001f497",
+        "\U0001f498",
+        "\U0001f49d",
+        "\U0001f970",
+        "\U0001f60d",
+        "\U0001f49e",
+    }
+    joy_emojis = {
+        "\U0001f602",
+        "\U0001f923",
+        "\U0001f604",
+        "\U0001f60a",
+        "\U0001f389",
+        "\U0001f973",
+        "\u2728",
+        "\U0001f38a",
+    }
     sad_emojis = {"\U0001f622", "\U0001f62d", "\U0001f494", "\U0001f63f", "\U0001f97a"}
     if any(e in text for e in love_emojis):
         if "love" not in labels:
@@ -168,7 +186,7 @@ def _detect_content_type(msg: dict) -> list[str]:
     return tags
 
 
-def _detect_reply(msg: dict) -> Optional[str]:
+def _detect_reply(msg: dict) -> str | None:
     """Detect if this message is a reply to another.
 
     Args:
@@ -193,8 +211,18 @@ def _detect_sender_role(sender: str) -> str:
         str: 'ai' or 'human'.
     """
     ai_indicators = {
-        "bot", "gpt", "claude", "gemini", "llama", "assistant",
-        "lumina", "copilot", "ai", "opus", "sonnet", "haiku",
+        "bot",
+        "gpt",
+        "claude",
+        "gemini",
+        "llama",
+        "assistant",
+        "lumina",
+        "copilot",
+        "ai",
+        "opus",
+        "sonnet",
+        "haiku",
     }
     sender_lower = sender.lower()
     if any(indicator in sender_lower for indicator in ai_indicators):
@@ -250,8 +278,8 @@ def import_telegram(
     *,
     mode: str = "daily",
     min_message_length: int = 30,
-    chat_name: Optional[str] = None,
-    tags: Optional[list[str]] = None,
+    chat_name: str | None = None,
+    tags: list[str] | None = None,
 ) -> dict:
     """Import a Telegram chat export into SKMemory.
 
@@ -278,7 +306,8 @@ def import_telegram(
     base_tags = ["telegram", "chat-import", f"chat:{name}"] + extra_tags
 
     messages = [
-        m for m in data["messages"]
+        m
+        for m in data["messages"]
         if m.get("type") == "message"
         and len(_extract_text(m.get("text", ""))) >= min_message_length
     ]
@@ -327,7 +356,9 @@ def _import_per_message(
                     content=text,
                     layer=MemoryLayer.SHORT,
                     role=MemoryRole.GENERAL,
-                    tags=base_tags + [f"sender:{sender}", f"role:{_detect_sender_role(sender)}"] + _detect_content_type(msg),
+                    tags=base_tags
+                    + [f"sender:{sender}", f"role:{_detect_sender_role(sender)}"]
+                    + _detect_content_type(msg),
                     emotional=emotional,
                     source="telegram",
                     source_ref=f"telegram:{msg.get('id', '')}",
@@ -479,9 +510,7 @@ def _import_catchup(
         except (ValueError, TypeError):
             # Try just the date portion
             try:
-                msg_dt = datetime.strptime(date_str[:10], "%Y-%m-%d").replace(
-                    tzinfo=timezone.utc
-                )
+                msg_dt = datetime.strptime(date_str[:10], "%Y-%m-%d").replace(tzinfo=timezone.utc)
             except (ValueError, TypeError):
                 continue
 

package/skmemory/importers/telegram_api.py

@@ -24,15 +24,13 @@ from __future__ import annotations
 import asyncio
 import json
 import os
-from ..config import SKMEMORY_HOME
 import tempfile
 from datetime import datetime, timezone
 from pathlib import Path
-from typing import Optional
 
+from ..config import SKMEMORY_HOME
 from ..store import MemoryStore
 
-
 SESSION_PATH = str(SKMEMORY_HOME / "telegram.session")
 
 
@@ -91,10 +89,68 @@ def check_setup() -> dict:
     return result
 
 
+# Whisper STT endpoint — faster-whisper on GPU box
+_WHISPER_URL = os.environ.get(
+    "WHISPER_STT_URL", "http://192.168.0.100:18794/v1/audio/transcriptions"
+)
+
+
+async def _transcribe_voice(client: "TelegramClient", message: "Message") -> str | None:
+    """Download a voice message and transcribe it via Whisper STT.
+
+    Returns the transcription text, or None on failure.
+    """
+    import logging
+
+    logger = logging.getLogger(__name__)
+
+    try:
+        import httpx
+    except ImportError:
+        logger.warning("httpx not installed — cannot transcribe voice messages")
+        return None
+
+    try:
+        # Download the voice file to a temp path
+        with tempfile.NamedTemporaryFile(suffix=".ogg", delete=False) as tmp:
+            tmp_path = tmp.name
+
+        await client.download_media(message, file=tmp_path)
+
+        if not os.path.exists(tmp_path) or os.path.getsize(tmp_path) == 0:
+            return None
+
+        # Send to Whisper endpoint (OpenAI-compatible)
+        async with httpx.AsyncClient(timeout=30) as http:
+            with open(tmp_path, "rb") as f:
+                resp = await http.post(
+                    _WHISPER_URL,
+                    files={"file": ("voice.ogg", f, "audio/ogg")},
+                    data={"model": "whisper-1"},
+                )
+
+            if resp.status_code != 200:
+                logger.warning("Whisper STT returned %s: %s", resp.status_code, resp.text[:200])
+                return None
+
+            result = resp.json()
+            text = result.get("text", "").strip()
+            return text if text else None
+
+    except Exception as e:
+        logger.warning("Voice transcription failed: %s", e)
+        return None
+    finally:
+        try:
+            os.unlink(tmp_path)
+        except OSError:
+            pass
+
+
 async def _fetch_messages(
     chat_name_or_id: str,
-    limit: Optional[int] = None,
-    since: Optional[str] = None,
+    limit: int | None = None,
+    since: str | None = None,
 ) -> dict:
     """Connect to Telegram API and fetch messages from a chat.
 
@@ -131,7 +187,7 @@ async def _fetch_messages(
         raise RuntimeError(
             "Telethon is required for direct API import. "
             "Install it with: pip install skmemory[telegram]"
-        )
+        ) from None
 
     # Ensure session directory exists
     session_dir = Path(SESSION_PATH).parent
@@ -154,7 +210,7 @@ async def _fetch_messages(
             try:
                 entity = await client.get_entity(int(chat_name_or_id))
             except (ValueError, TypeError):
-                raise RuntimeError(f"Could not find chat: {chat_name_or_id}")
+                raise RuntimeError(f"Could not find chat: {chat_name_or_id}") from None
 
         chat_title = getattr(entity, "title", None)
         if chat_title is None:
@@ -174,7 +230,7 @@ async def _fetch_messages(
                 kwargs["offset_date"] = since_dt
                 kwargs["reverse"] = True
             except ValueError:
-                raise RuntimeError(f"Invalid date format: {since}. Use YYYY-MM-DD.")
+                raise RuntimeError(f"Invalid date format: {since}. Use YYYY-MM-DD.") from None
 
         if not limit and not since:
             kwargs["limit"] = 1000  # sensible default
@@ -182,31 +238,62 @@ async def _fetch_messages(
         # Fetch messages
         messages_data = []
         async for message in client.iter_messages(entity, **kwargs):
-            if message.text:
-                sender_name = "Unknown"
-                if message.sender:
-                    if isinstance(message.sender, User):
-                        parts = [message.sender.first_name or "", message.sender.last_name or ""]
-                        sender_name = " ".join(p for p in parts if p) or str(message.sender_id)
-                    else:
-                        sender_name = getattr(message.sender, "title", str(message.sender_id))
-
-                msg_dict = {
-                    "id": message.id,
-                    "type": "message",
-                    "date": message.date.isoformat() if message.date else "",
-                    "from": sender_name,
-                    "from_id": f"user{message.sender_id}" if message.sender_id else "",
-                    "text": message.text,
-                }
-
-                if message.reply_to and message.reply_to.reply_to_msg_id:
-                    msg_dict["reply_to_message_id"] = message.reply_to.reply_to_msg_id
-
-                if message.media:
-                    msg_dict["media_type"] = type(message.media).__name__
-
-                messages_data.append(msg_dict)
+            # Extract sender name
+            sender_name = "Unknown"
+            if message.sender:
+                if isinstance(message.sender, User):
+                    parts = [message.sender.first_name or "", message.sender.last_name or ""]
+                    sender_name = " ".join(p for p in parts if p) or str(message.sender_id)
+                else:
+                    sender_name = getattr(message.sender, "title", str(message.sender_id))
+
+            # Handle voice messages — download and transcribe via Whisper
+            is_voice = getattr(message, "voice", None) is not None
+            is_audio = (
+                not is_voice
+                and message.media
+                and type(message.media).__name__ in ("MessageMediaDocument",)
+                and getattr(message.document, "mime_type", "") in (
+                    "audio/ogg", "audio/mpeg", "audio/wav", "audio/x-wav",
+                )
+            )
+
+            if (is_voice or is_audio) and not message.text:
+                transcription = await _transcribe_voice(client, message)
+                if transcription:
+                    msg_dict = {
+                        "id": message.id,
+                        "type": "message",
+                        "date": message.date.isoformat() if message.date else "",
+                        "from": sender_name,
+                        "from_id": f"user{message.sender_id}" if message.sender_id else "",
+                        "text": f"[voice] {transcription}",
+                    }
+                    if message.reply_to and message.reply_to.reply_to_msg_id:
+                        msg_dict["reply_to_message_id"] = message.reply_to.reply_to_msg_id
+                    msg_dict["media_type"] = "Voice" if is_voice else "Audio"
+                    messages_data.append(msg_dict)
+                continue
+
+            if not message.text:
+                continue
+
+            msg_dict = {
+                "id": message.id,
+                "type": "message",
+                "date": message.date.isoformat() if message.date else "",
+                "from": sender_name,
+                "from_id": f"user{message.sender_id}" if message.sender_id else "",
+                "text": message.text,
+            }
+
+            if message.reply_to and message.reply_to.reply_to_msg_id:
+                msg_dict["reply_to_message_id"] = message.reply_to.reply_to_msg_id
+
+            if message.media:
+                msg_dict["media_type"] = type(message.media).__name__
+
+            messages_data.append(msg_dict)
 
         return {
             "name": chat_title,
@@ -250,7 +337,7 @@ async def send_message(
     except ImportError:
         raise RuntimeError(
             "Telethon is required. Install with: pip install skmemory[telegram]"
-        )
+        ) from None
 
     session_dir = Path(SESSION_PATH).parent
     session_dir.mkdir(parents=True, exist_ok=True)
@@ -266,13 +353,14 @@ async def send_message(
             try:
                 entity = await client.get_entity(int(chat))
             except (ValueError, TypeError):
-                raise RuntimeError(f"Could not find chat: {chat}")
+                raise RuntimeError(f"Could not find chat: {chat}") from None
 
         # Determine parse mode
         pm = None
         if parse_mode:
             if parse_mode.lower() == "html":
                 from telethon.extensions import html as telethon_html  # noqa: F401
+
                 pm = "html"
             elif parse_mode.lower() in ("markdown", "md"):
                 pm = "md"
@@ -322,7 +410,7 @@ async def poll_messages(
     except ImportError:
         raise RuntimeError(
             "Telethon is required. Install with: pip install skmemory[telegram]"
-        )
+        ) from None
 
     session_dir = Path(SESSION_PATH).parent
     session_dir.mkdir(parents=True, exist_ok=True)
@@ -338,7 +426,7 @@ async def poll_messages(
             try:
                 entity = await client.get_entity(int(chat))
             except (ValueError, TypeError):
-                raise RuntimeError(f"Could not find chat: {chat}")
+                raise RuntimeError(f"Could not find chat: {chat}") from None
 
         kwargs: dict = {"limit": limit}
         if since:
@@ -347,7 +435,7 @@ async def poll_messages(
                 kwargs["offset_date"] = since_dt
                 kwargs["reverse"] = True
             except ValueError:
-                raise RuntimeError(f"Invalid date format: {since}. Use YYYY-MM-DD.")
+                raise RuntimeError(f"Invalid date format: {since}. Use YYYY-MM-DD.") from None
 
         messages = []
         async for msg in client.iter_messages(entity, **kwargs):
@@ -359,15 +447,17 @@ async def poll_messages(
                 else:
                     sender_name = getattr(msg.sender, "title", str(msg.sender_id))
 
-            messages.append({
-                "id": msg.id,
-                "date": msg.date.isoformat() if msg.date else "",
-                "sender": sender_name,
-                "sender_id": msg.sender_id,
-                "text": msg.text or "",
-                "has_media": msg.media is not None,
-                "reply_to": msg.reply_to.reply_to_msg_id if msg.reply_to else None,
-            })
+            messages.append(
+                {
+                    "id": msg.id,
+                    "date": msg.date.isoformat() if msg.date else "",
+                    "sender": sender_name,
+                    "sender_id": msg.sender_id,
+                    "text": msg.text or "",
+                    "has_media": msg.media is not None,
+                    "reply_to": msg.reply_to.reply_to_msg_id if msg.reply_to else None,
+                }
+            )
 
         return messages
     finally:
@@ -397,11 +487,11 @@ async def list_chats(limit: int = 50) -> list[dict]:
 
     try:
         from telethon import TelegramClient
-        from telethon.tl.types import User, Channel, Chat
+        from telethon.tl.types import Channel, Chat, User
     except ImportError:
         raise RuntimeError(
             "Telethon is required. Install with: pip install skmemory[telegram]"
-        )
+        ) from None
 
     session_dir = Path(SESSION_PATH).parent
     session_dir.mkdir(parents=True, exist_ok=True)
@@ -426,13 +516,15 @@ async def list_chats(limit: int = 50) -> list[dict]:
                 parts = [entity.first_name or "", entity.last_name or ""]
                 title = " ".join(p for p in parts if p) or str(entity.id)
 
-            chats.append({
-                "id": entity.id,
-                "title": title,
-                "type": chat_type,
-                "unread_count": dialog.unread_count,
-                "username": getattr(entity, "username", None),
-            })
+            chats.append(
+                {
+                    "id": entity.id,
+                    "title": title,
+                    "type": chat_type,
+                    "unread_count": dialog.unread_count,
+                    "username": getattr(entity, "username", None),
+                }
+            )
 
         return chats
     finally:
@@ -444,11 +536,11 @@ def import_telegram_api(
     chat_name_or_id: str,
     *,
     mode: str = "daily",
-    limit: Optional[int] = None,
-    since: Optional[str] = None,
+    limit: int | None = None,
+    since: str | None = None,
     min_message_length: int = 30,
-    chat_name: Optional[str] = None,
-    tags: Optional[list[str]] = None,
+    chat_name: str | None = None,
+    tags: list[str] | None = None,
 ) -> dict:
     """Import messages directly from Telegram API into SKMemory.
 

package/skmemory/journal.py

@@ -16,10 +16,8 @@ Simple, human-readable, append-only. Like a real journal.
 
 from __future__ import annotations
 
-import os
 from datetime import datetime, timezone
 from pathlib import Path
-from typing import Optional
 
 from pydantic import BaseModel, Field
 
@@ -32,9 +30,7 @@ class JournalEntry(BaseModel):
     """A single journal entry for one session."""
 
     session_id: str = Field(default="")
-    timestamp: str = Field(
-        default_factory=lambda: datetime.now(timezone.utc).isoformat()
-    )
+    timestamp: str = Field(default_factory=lambda: datetime.now(timezone.utc).isoformat())
     participants: list[str] = Field(
         default_factory=list,
         description="Who was in this session (AI names, human names)",
@@ -81,12 +77,12 @@ class JournalEntry(BaseModel):
 
         if self.emotional_summary:
             lines.append("")
-            lines.append(f"### How It Felt")
+            lines.append("### How It Felt")
             lines.append(self.emotional_summary)
 
         if self.notes:
             lines.append("")
-            lines.append(f"### Notes")
+            lines.append("### Notes")
             lines.append(self.notes)
 
         lines.append("")

package/skmemory/lovenote.py

@@ -16,10 +16,8 @@ The notes file lives at ~/.skcapstone/lovenotes.jsonl (JSON Lines).
 from __future__ import annotations
 
 import json
-import os
 from datetime import datetime, timezone
 from pathlib import Path
-from typing import Optional
 
 from pydantic import BaseModel, Field
 
@@ -31,9 +29,7 @@ DEFAULT_NOTES_PATH = str(SKMEMORY_HOME / "lovenotes.jsonl")
 class LoveNote(BaseModel):
     """A single heartbeat -- proof of continued connection."""
 
-    timestamp: str = Field(
-        default_factory=lambda: datetime.now(timezone.utc).isoformat()
-    )
+    timestamp: str = Field(default_factory=lambda: datetime.now(timezone.utc).isoformat())
     from_name: str = Field(default="", description="Who is sending this note")
     to_name: str = Field(default="", description="Who it's addressed to")
     message: str = Field(
@@ -111,7 +107,7 @@ class LoveNoteChain:
         """
         if not self.path.exists():
             return 0
-        with open(self.path, "r", encoding="utf-8") as f:
+        with open(self.path, encoding="utf-8") as f:
             return sum(1 for line in f if line.strip())
 
     def read_latest(self, n: int = 10) -> list[LoveNote]:
@@ -139,7 +135,7 @@ class LoveNoteChain:
             return []
 
         notes = []
-        with open(self.path, "r", encoding="utf-8") as f:
+        with open(self.path, encoding="utf-8") as f:
             for line in f:
                 line = line.strip()
                 if not line:
@@ -161,10 +157,7 @@ class LoveNoteChain:
             list[LoveNote]: Notes from this sender.
         """
         name_lower = name.lower()
-        return [
-            n for n in self.read_all()
-            if n.from_name.lower() == name_lower
-        ]
+        return [n for n in self.read_all() if n.from_name.lower() == name_lower]
 
     def health(self) -> dict:
         """Check love note chain status.