Skip to content

An always-on second brain you talk to. Voice notes in Telegram → typed, linked knowledge in your Obsidian vault. Runs 24/7 on the Claude subscription you already have.

feat(session): integrate SessionStore across all handlers

smixsc1bc579b4d09
diff --git a/src/d_brain/bot/handlers/commands.py b/src/d_brain/bot/handlers/commands.py
index 0059775..d423565 100644
--- a/src/d_brain/bot/handlers/commands.py
+++ b/src/d_brain/bot/handlers/commands.py
@@ -8,6 +8,7 @@ from aiogram.types import Message
from d_brain.bot.keyboards import get_main_keyboard
from d_brain.config import get_settings
+from d_brain.services.session import SessionStore
from d_brain.services.storage import VaultStorage
router = Router(name="commands")
@@ -57,9 +58,14 @@ async def cmd_help(message: Message) -> None:
@router.message(Command("status"))
async def cmd_status(message: Message) -> None:
"""Handle /status command."""
+ user_id = message.from_user.id if message.from_user else 0
settings = get_settings()
storage = VaultStorage(settings.vault_path)
+ # Log command
+ session = SessionStore(settings.vault_path)
+ session.append(user_id, "command", cmd="/status")
+
today = date.today()
content = storage.read_daily(today)
@@ -77,6 +83,14 @@ async def cmd_status(message: Message) -> None:
total = len(entries)
+ # Get weekly stats from session
+ week_stats = ""
+ stats = session.get_stats(user_id, days=7)
+ if stats:
+ week_stats = "\n\n<b>За 7 дней:</b>"
+ for entry_type, count in sorted(stats.items()):
+ week_stats += f"\n• {entry_type}: {count}"
+
await message.answer(
f"📅 <b>{today}</b>\n\n"
f"Всего записей: <b>{total}</b>\n"
@@ -84,4 +98,5 @@ async def cmd_status(message: Message) -> None:
f"- 💬 Текстовых: {text_count}\n"
f"- 📷 Фото: {photo_count}\n"
f"- ↩️ Пересланных: {forward_count}"
+ f"{week_stats}"
)
diff --git a/src/d_brain/bot/handlers/do.py b/src/d_brain/bot/handlers/do.py
index 3093639..bb07208 100644
--- a/src/d_brain/bot/handlers/do.py
+++ b/src/d_brain/bot/handlers/do.py
@@ -21,9 +21,11 @@ logger = logging.getLogger(__name__)
@router.message(Command("do"))
async def cmd_do(message: Message, command: CommandObject, state: FSMContext) -> None:
"""Handle /do command."""
+ user_id = message.from_user.id if message.from_user else 0
+
# Check for inline text: /do move overdue tasks
if command.args:
- await process_request(message, command.args)
+ await process_request(message, command.args, user_id)
return
# Otherwise, wait for next message
@@ -80,10 +82,11 @@ async def handle_do_input(message: Message, bot: Bot, state: FSMContext) -> None
await message.answer("❌ Отправь текст или голосовое сообщение")
return
- await process_request(message, prompt)
+ user_id = message.from_user.id if message.from_user else 0
+ await process_request(message, prompt, user_id)
-async def process_request(message: Message, prompt: str) -> None:
+async def process_request(message: Message, prompt: str, user_id: int = 0) -> None:
"""Process the user's request with Claude."""
status_msg = await message.answer("⏳ Выполняю...")
@@ -92,7 +95,7 @@ async def process_request(message: Message, prompt: str) -> None:
async def run_with_progress() -> dict:
task = asyncio.create_task(
- asyncio.to_thread(processor.execute_prompt, prompt)
+ asyncio.to_thread(processor.execute_prompt, prompt, user_id)
)
elapsed = 0
diff --git a/src/d_brain/bot/handlers/forward.py b/src/d_brain/bot/handlers/forward.py
index 6f73c56..e9320a3 100644
--- a/src/d_brain/bot/handlers/forward.py
+++ b/src/d_brain/bot/handlers/forward.py
@@ -7,6 +7,7 @@ from aiogram import Router
from aiogram.types import Message
from d_brain.config import get_settings
+from d_brain.services.session import SessionStore
from d_brain.services.storage import VaultStorage
router = Router(name="forward")
@@ -43,5 +44,15 @@ async def handle_forward(message: Message) -> None:
timestamp = datetime.fromtimestamp(message.date.timestamp())
storage.append_to_daily(content, timestamp, msg_type)
+ # Log to session
+ session = SessionStore(settings.vault_path)
+ session.append(
+ message.from_user.id,
+ "forward",
+ text=content,
+ source=source_name,
+ msg_id=message.message_id,
+ )
+
await message.answer(f"✓ Сохранено (от {source_name})")
logger.info("Forwarded message saved from: %s", source_name)
diff --git a/src/d_brain/bot/handlers/photo.py b/src/d_brain/bot/handlers/photo.py
index 4cf6aa4..9d75c85 100644
--- a/src/d_brain/bot/handlers/photo.py
+++ b/src/d_brain/bot/handlers/photo.py
@@ -7,6 +7,7 @@ from aiogram import Bot, Router
from aiogram.types import Message
from d_brain.config import get_settings
+from d_brain.services.session import SessionStore
from d_brain.services.storage import VaultStorage
router = Router(name="photo")
@@ -59,6 +60,16 @@ async def handle_photo(message: Message, bot: Bot) -> None:
storage.append_to_daily(content, timestamp, "[photo]")
+ # Log to session
+ session = SessionStore(settings.vault_path)
+ session.append(
+ message.from_user.id,
+ "photo",
+ path=relative_path,
+ caption=message.caption,
+ msg_id=message.message_id,
+ )
+
await message.answer("📷 ✓ Сохранено")
logger.info("Photo saved: %s", relative_path)
diff --git a/src/d_brain/bot/handlers/text.py b/src/d_brain/bot/handlers/text.py
index e77814b..e0e7cb0 100644
--- a/src/d_brain/bot/handlers/text.py
+++ b/src/d_brain/bot/handlers/text.py
@@ -7,6 +7,7 @@ from aiogram import Router
from aiogram.types import Message
from d_brain.config import get_settings
+from d_brain.services.session import SessionStore
from d_brain.services.storage import VaultStorage
router = Router(name="text")
@@ -25,5 +26,14 @@ async def handle_text(message: Message) -> None:
timestamp = datetime.fromtimestamp(message.date.timestamp())
storage.append_to_daily(message.text, timestamp, "[text]")
+ # Log to session
+ session = SessionStore(settings.vault_path)
+ session.append(
+ message.from_user.id,
+ "text",
+ text=message.text,
+ msg_id=message.message_id,
+ )
+
await message.answer("✓ Сохранено")
logger.info("Text message saved: %d chars", len(message.text))
diff --git a/src/d_brain/bot/handlers/voice.py b/src/d_brain/bot/handlers/voice.py
index af56cc0..64cb972 100644
--- a/src/d_brain/bot/handlers/voice.py
+++ b/src/d_brain/bot/handlers/voice.py
@@ -7,6 +7,7 @@ from aiogram import Bot, Router
from aiogram.types import Message
from d_brain.config import get_settings
+from d_brain.services.session import SessionStore
from d_brain.services.storage import VaultStorage
from d_brain.services.transcription import DeepgramTranscriber
@@ -47,6 +48,16 @@ async def handle_voice(message: Message, bot: Bot) -> None:
timestamp = datetime.fromtimestamp(message.date.timestamp())
storage.append_to_daily(transcript, timestamp, "[voice]")
+ # Log to session
+ session = SessionStore(settings.vault_path)
+ session.append(
+ message.from_user.id,
+ "voice",
+ text=transcript,
+ duration=message.voice.duration,
+ msg_id=message.message_id,
+ )
+
await message.answer(f"🎤 {transcript}\n\n✓ Сохранено")
logger.info("Voice message saved: %d chars", len(transcript))
diff --git a/src/d_brain/services/processor.py b/src/d_brain/services/processor.py
index 2ac8fcd..41bd0da 100644
--- a/src/d_brain/services/processor.py
+++ b/src/d_brain/services/processor.py
@@ -1,6 +1,5 @@
"""Claude processing service."""
-import json
import logging
import os
import subprocess
@@ -8,6 +7,8 @@ from datetime import date
from pathlib import Path
from typing import Any
+from d_brain.services.session import SessionStore
+
logger = logging.getLogger(__name__)
DEFAULT_TIMEOUT = 1200 # 20 minutes
@@ -39,6 +40,33 @@ class ClaudeProcessor:
return ref_path.read_text()
return ""
+ def _get_session_context(self, user_id: int) -> str:
+ """Get today's session context for Claude.
+
+ Args:
+ user_id: Telegram user ID
+
+ Returns:
+ Recent session entries formatted for inclusion in prompt.
+ """
+ if user_id == 0:
+ return ""
+
+ session = SessionStore(self.vault_path)
+ today_entries = session.get_today(user_id)
+ if not today_entries:
+ return ""
+
+ lines = ["=== TODAY'S SESSION ==="]
+ for entry in today_entries[-10:]:
+ ts = entry.get("ts", "")[11:16] # HH:MM from ISO
+ entry_type = entry.get("type", "unknown")
+ text = entry.get("text", "")[:80]
+ if text:
+ lines.append(f"{ts} [{entry_type}] {text}")
+ lines.append("=== END SESSION ===\n")
+ return "\n".join(lines)
+
def _html_to_markdown(self, html: str) -> str:
"""Convert Telegram HTML to Obsidian Markdown."""
import re
@@ -198,19 +226,21 @@ CRITICAL OUTPUT FORMAT:
"processed_entries": 0,
}
- def execute_prompt(self, user_prompt: str) -> dict[str, Any]:
+ def execute_prompt(self, user_prompt: str, user_id: int = 0) -> dict[str, Any]:
"""Execute arbitrary prompt with Claude.
Args:
user_prompt: User's natural language request
+ user_id: Telegram user ID for session context
Returns:
Execution report as dict
"""
today = date.today()
- # Load todoist reference for task operations
+ # Load context
todoist_ref = self._load_todoist_reference()
+ session_context = self._get_session_context(user_id)
prompt = f"""Ты - персональный ассистент d-brain.
@@ -218,7 +248,7 @@ CONTEXT:
- Текущая дата: {today}
- Vault path: {self.vault_path}
-=== TODOIST REFERENCE ===
+{session_context}=== TODOIST REFERENCE ===
{todoist_ref}
=== END REFERENCE ===
diff --git a/src/d_brain/services/session.py b/src/d_brain/services/session.py
index d4b79cd..1f51ff5 100644
--- a/src/d_brain/services/session.py
+++ b/src/d_brain/services/session.py
@@ -1,164 +1,106 @@
-"""JSONL-based session persistence for storing all interactions."""
+"""Session persistence service.
+
+Stores all bot interactions in JSONL format for history and analytics.
+Inspired by Clawdbot's session persistence pattern.
+"""
import json
-from dataclasses import asdict, dataclass
-from datetime import date, datetime
+from datetime import datetime
from pathlib import Path
from typing import Any
-@dataclass
-class SessionEntry:
- """Single session entry."""
-
- timestamp: str
- type: str # voice, text, photo, forward, command
- content: str
- metadata: dict[str, Any] | None = None
-
- def to_dict(self) -> dict[str, Any]:
- """Convert to dictionary for JSON serialization."""
- return {k: v for k, v in asdict(self).items() if v is not None}
+class SessionStore:
+ """Persistent session storage in JSONL format.
-
-class SessionStorage:
- """JSONL-based session storage for append-only reliability.
-
- Stores all interactions in daily JSONL files for later analysis
- and context retrieval.
+ Each user gets their own session file at vault/.sessions/{user_id}.jsonl.
+ Entries are append-only for reliability and simplicity.
"""
- def __init__(self, vault_path: Path) -> None:
- self.vault_path = Path(vault_path)
- self.sessions_path = self.vault_path / "sessions"
-
- def _ensure_dirs(self) -> None:
- """Ensure sessions directory exists."""
- self.sessions_path.mkdir(parents=True, exist_ok=True)
+ def __init__(self, vault_path: Path | str) -> None:
+ self.sessions_dir = Path(vault_path) / ".sessions"
+ self.sessions_dir.mkdir(exist_ok=True)
- def _get_session_file(self, day: date) -> Path:
- """Get path to session file for given date."""
- self._ensure_dirs()
- return self.sessions_path / f"{day.isoformat()}.jsonl"
+ def _get_session_file(self, user_id: int) -> Path:
+ return self.sessions_dir / f"{user_id}.jsonl"
- def append(
- self,
- entry_type: str,
- content: str,
- timestamp: datetime | None = None,
- metadata: dict[str, Any] | None = None,
- ) -> None:
- """Append entry to session file.
+ def append(self, user_id: int, entry_type: str, **data: Any) -> None:
+ """Append entry to user's session file.
Args:
- entry_type: Type of entry (voice, text, photo, forward, command)
- content: Entry content
- timestamp: Entry timestamp (defaults to now)
- metadata: Optional metadata dict
+ user_id: Telegram user ID
+ entry_type: Type of entry (voice, text, photo, forward, command, etc.)
+ **data: Additional data to store (text, duration, msg_id, etc.)
"""
- if timestamp is None:
- timestamp = datetime.now()
-
- entry = SessionEntry(
- timestamp=timestamp.isoformat(),
- type=entry_type,
- content=content,
- metadata=metadata,
- )
-
- file_path = self._get_session_file(timestamp.date())
- with file_path.open("a", encoding="utf-8") as f:
- f.write(json.dumps(entry.to_dict(), ensure_ascii=False) + "\n")
-
- def get_today(self) -> list[SessionEntry]:
- """Get all entries for today."""
- return self.get_day(date.today())
-
- def get_day(self, day: date) -> list[SessionEntry]:
- """Get all entries for a specific day."""
- file_path = self._get_session_file(day)
- if not file_path.exists():
- return []
+ entry = {
+ "ts": datetime.now().astimezone().isoformat(),
+ "type": entry_type,
+ **data,
+ }
+ path = self._get_session_file(user_id)
+ with path.open("a", encoding="utf-8") as f:
+ f.write(json.dumps(entry, ensure_ascii=False) + "\n")
- entries = []
- with file_path.open("r", encoding="utf-8") as f:
- for line in f:
- line = line.strip()
- if line:
- data = json.loads(line)
- entries.append(
- SessionEntry(
- timestamp=data["timestamp"],
- type=data["type"],
- content=data["content"],
- metadata=data.get("metadata"),
- )
- )
- return entries
-
- def get_recent(self, days: int = 7) -> list[SessionEntry]:
- """Get entries from the last N days.
+ def get_recent(self, user_id: int, limit: int = 50) -> list[dict]:
+ """Get recent session entries.
Args:
- days: Number of days to look back (default 7)
+ user_id: Telegram user ID
+ limit: Maximum number of entries to return
Returns:
- List of entries sorted by timestamp (oldest first)
+ List of session entries, most recent last
"""
- from datetime import timedelta
+ path = self._get_session_file(user_id)
+ if not path.exists():
+ return []
entries = []
- today = date.today()
+ with path.open("r", encoding="utf-8") as f:
+ for line in f:
+ if line.strip():
+ try:
+ entries.append(json.loads(line))
+ except json.JSONDecodeError:
+ continue # Skip malformed lines
- for i in range(days):
- day = today - timedelta(days=i)
- entries.extend(self.get_day(day))
+ return entries[-limit:]
- # Sort by timestamp (oldest first)
- entries.sort(key=lambda e: e.timestamp)
- return entries
+ def get_today(self, user_id: int) -> list[dict]:
+ """Get today's session entries.
- def get_stats(self) -> dict[str, Any]:
- """Get statistics about stored sessions.
+ Args:
+ user_id: Telegram user ID
Returns:
- Dict with stats: total_entries, by_type, by_day, date_range
+ List of today's entries
"""
- stats: dict[str, Any] = {
- "total_entries": 0,
- "by_type": {},
- "by_day": {},
- "date_range": {"first": None, "last": None},
- }
-
- if not self.sessions_path.exists():
- return stats
+ today = datetime.now().date().isoformat()
+ return [
+ e
+ for e in self.get_recent(user_id, limit=200)
+ if e.get("ts", "").startswith(today)
+ ]
- session_files = sorted(self.sessions_path.glob("*.jsonl"))
- if not session_files:
- return stats
+ def get_stats(self, user_id: int, days: int = 7) -> dict[str, int]:
+ """Get usage statistics for the last N days.
- # Parse first and last dates from filenames
- stats["date_range"]["first"] = session_files[0].stem
- stats["date_range"]["last"] = session_files[-1].stem
-
- for file_path in session_files:
- day = file_path.stem
- day_count = 0
+ Args:
+ user_id: Telegram user ID
+ days: Number of days to analyze
- with file_path.open("r", encoding="utf-8") as f:
- for line in f:
- line = line.strip()
- if line:
- data = json.loads(line)
- entry_type = data.get("type", "unknown")
+ Returns:
+ Dict with counts by entry type
+ """
+ from datetime import timedelta
- stats["total_entries"] += 1
- day_count += 1
- stats["by_type"][entry_type] = (
- stats["by_type"].get(entry_type, 0) + 1
- )
+ cutoff = (datetime.now() - timedelta(days=days)).isoformat()
+ entries = self.get_recent(user_id, limit=1000)
- stats["by_day"][day] = day_count
+ stats: dict[str, int] = {}
+ for entry in entries:
+ if entry.get("ts", "") >= cutoff:
+ entry_type = entry.get("type", "unknown")
+ stats[entry_type] = stats.get(entry_type, 0) + 1
return stats