gobby 0.2.5__py3-none-any.whl

gobby/storage/projects.py

@@ -0,0 +1,166 @@
+"""Local project storage manager."""
+
+import logging
+import uuid
+from dataclasses import dataclass
+from datetime import UTC, datetime
+from typing import Any
+
+from gobby.storage.database import DatabaseProtocol
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class Project:
+    """Project data model."""
+
+    id: str
+    name: str
+    repo_path: str | None
+    github_url: str | None
+    created_at: str
+    updated_at: str
+    github_repo: str | None = None  # GitHub repo in "owner/repo" format
+    linear_team_id: str | None = None  # Linear team ID for project sync
+
+    @classmethod
+    def from_row(cls, row: Any) -> "Project":
+        """Create Project from database row."""
+        return cls(
+            id=row["id"],
+            name=row["name"],
+            repo_path=row["repo_path"],
+            github_url=row["github_url"],
+            created_at=row["created_at"],
+            updated_at=row["updated_at"],
+            github_repo=row["github_repo"] if "github_repo" in row.keys() else None,
+            linear_team_id=row["linear_team_id"] if "linear_team_id" in row.keys() else None,
+        )
+
+    def to_dict(self) -> dict[str, Any]:
+        """Convert to dictionary."""
+        return {
+            "id": self.id,
+            "name": self.name,
+            "repo_path": self.repo_path,
+            "github_url": self.github_url,
+            "github_repo": self.github_repo,
+            "linear_team_id": self.linear_team_id,
+            "created_at": self.created_at,
+            "updated_at": self.updated_at,
+        }
+
+
+class LocalProjectManager:
+    """Manager for local project storage."""
+
+    def __init__(self, db: DatabaseProtocol):
+        """Initialize with database connection."""
+        self.db = db
+
+    def create(
+        self,
+        name: str,
+        repo_path: str | None = None,
+        github_url: str | None = None,
+    ) -> Project:
+        """
+        Create a new project.
+
+        Args:
+            name: Unique project name
+            repo_path: Local repository path
+            github_url: GitHub repository URL
+
+        Returns:
+            Created Project instance
+        """
+        project_id = str(uuid.uuid4())
+        now = datetime.now(UTC).isoformat()
+
+        self.db.execute(
+            """
+            INSERT INTO projects (id, name, repo_path, github_url, created_at, updated_at)
+            VALUES (?, ?, ?, ?, ?, ?)
+            """,
+            (project_id, name, repo_path, github_url, now, now),
+        )
+
+        return Project(
+            id=project_id,
+            name=name,
+            repo_path=repo_path,
+            github_url=github_url,
+            created_at=now,
+            updated_at=now,
+        )
+
+    def get(self, project_id: str) -> Project | None:
+        """Get project by ID."""
+        row = self.db.fetchone("SELECT * FROM projects WHERE id = ?", (project_id,))
+        return Project.from_row(row) if row else None
+
+    def get_by_name(self, name: str) -> Project | None:
+        """Get project by name."""
+        row = self.db.fetchone("SELECT * FROM projects WHERE name = ?", (name,))
+        return Project.from_row(row) if row else None
+
+    def get_or_create(
+        self,
+        name: str,
+        repo_path: str | None = None,
+        github_url: str | None = None,
+    ) -> Project:
+        """Get existing project or create new one."""
+        project = self.get_by_name(name)
+        if project:
+            return project
+        return self.create(name, repo_path, github_url)
+
+    def list(self) -> list[Project]:
+        """List all projects."""
+        rows = self.db.fetchall("SELECT * FROM projects ORDER BY name")
+        return [Project.from_row(row) for row in rows]
+
+    def update(self, project_id: str, **fields: Any) -> Project | None:
+        """
+        Update project fields.
+
+        Args:
+            project_id: Project ID
+            **fields: Fields to update (name, repo_path, github_url)
+
+        Returns:
+            Updated Project or None if not found
+        """
+        if not fields:
+            return self.get(project_id)
+
+        allowed = {"name", "repo_path", "github_url", "github_repo", "linear_team_id"}
+        fields = {k: v for k, v in fields.items() if k in allowed}
+        if not fields:
+            return self.get(project_id)
+
+        fields["updated_at"] = datetime.now(UTC).isoformat()
+
+        # nosec B608: Fields validated against allowlist above, values parameterized
+        set_clause = ", ".join(f"{k} = ?" for k in fields)
+        values = list(fields.values()) + [project_id]
+
+        self.db.execute(
+            f"UPDATE projects SET {set_clause} WHERE id = ?",  # nosec B608
+            tuple(values),
+        )
+
+        return self.get(project_id)
+
+    def delete(self, project_id: str) -> bool:
+        """
+        Delete project by ID.
+
+        Returns:
+            True if deleted, False if not found
+        """
+        cursor = self.db.execute("DELETE FROM projects WHERE id = ?", (project_id,))
+        return cursor.rowcount > 0

gobby/storage/session_messages.py

@@ -0,0 +1,251 @@
+"""
+Local storage for session messages.
+"""
+
+import asyncio
+import json
+import logging
+from typing import Any
+
+from gobby.sessions.transcripts.base import ParsedMessage
+from gobby.storage.database import DatabaseProtocol
+
+logger = logging.getLogger(__name__)
+
+
+class LocalSessionMessageManager:
+    """Manages storage of session messages and processing state."""
+
+    def __init__(self, database: DatabaseProtocol):
+        self.db = database
+
+    async def store_messages(self, session_id: str, messages: list[ParsedMessage]) -> int:
+        """
+        Store parsed messages for a session.
+
+        Args:
+            session_id: ID of the session
+            messages: List of ParsedMessage objects
+
+        Returns:
+            Number of messages stored
+        """
+        if not messages:
+            return 0
+
+        def _store_blocking() -> int:
+            # Check if session exists to avoid FOREIGN KEY constraint errors
+            # This can happen when sessions are created in hub-only mode but
+            # message processor is using the project database
+            session_exists = self.db.fetchone("SELECT 1 FROM sessions WHERE id = ?", (session_id,))
+            if not session_exists:
+                logger.debug(
+                    f"Session {session_id} not found in database, skipping message storage"
+                )
+                return 0
+
+            count = 0
+            for msg in messages:
+                # Convert dicts to JSON strings for storage
+                tool_input = json.dumps(msg.tool_input) if msg.tool_input is not None else None
+                tool_result = json.dumps(msg.tool_result) if msg.tool_result is not None else None
+                raw_json = json.dumps(msg.raw_json) if msg.raw_json is not None else None
+
+                query = """
+                INSERT INTO session_messages (
+                    session_id, message_index, role, content, content_type,
+                    tool_name, tool_input, tool_result, timestamp, raw_json
+                ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+                ON CONFLICT(session_id, message_index) DO UPDATE SET
+                    content=excluded.content,
+                    content_type=excluded.content_type,
+                    tool_name=excluded.tool_name,
+                    tool_input=excluded.tool_input,
+                    tool_result=excluded.tool_result,
+                    timestamp=excluded.timestamp,
+                    raw_json=excluded.raw_json
+                """
+
+                self.db.execute(
+                    query,
+                    (
+                        session_id,
+                        msg.index,
+                        msg.role,
+                        msg.content,
+                        msg.content_type,
+                        msg.tool_name,
+                        tool_input,
+                        tool_result,
+                        msg.timestamp.isoformat(),
+                        raw_json,
+                    ),
+                )
+                count += 1
+            return count
+
+        try:
+            return await asyncio.to_thread(_store_blocking)
+        except Exception as e:
+            logger.error(f"Failed to store messages for session {session_id}: {e}")
+            raise
+
+    async def get_messages(
+        self,
+        session_id: str,
+        limit: int = 100,
+        offset: int = 0,
+        role: str | None = None,
+    ) -> list[dict[str, Any]]:
+        """
+        Retrieve messages for a session.
+
+        Args:
+            session_id: Session ID
+            limit: Maximum number of messages to return
+            offset: Offset for pagination
+            role: Optional role to filter by
+
+        Returns:
+            List of message dictionaries
+        """
+        query = "SELECT * FROM session_messages WHERE session_id = ?"
+        params: list[Any] = [session_id]
+
+        if role:
+            query += " AND role = ?"
+            params.append(role)
+
+        query += " ORDER BY message_index ASC LIMIT ? OFFSET ?"
+        params.extend([limit, offset])
+
+        rows = await asyncio.to_thread(self.db.fetchall, query, tuple(params))
+        return [dict(row) for row in rows]
+
+    async def get_state(self, session_id: str) -> dict[str, Any] | None:
+        """
+        Get processing state for a session.
+
+        Args:
+            session_id: Session ID
+
+        Returns:
+            State dictionary or None if not found
+        """
+        row = await asyncio.to_thread(
+            self.db.fetchone,
+            "SELECT * FROM session_message_state WHERE session_id = ?",
+            (session_id,),
+        )
+        return dict(row) if row else None
+
+    async def update_state(
+        self,
+        session_id: str,
+        byte_offset: int,
+        message_index: int,
+    ) -> None:
+        """
+        Update processing state for a session.
+
+        Args:
+            session_id: Session ID
+            byte_offset: New byte offset in source file
+            message_index: Index of last processed message
+        """
+        # Check if session exists to avoid FOREIGN KEY constraint errors
+        session_exists = await asyncio.to_thread(
+            self.db.fetchone,
+            "SELECT 1 FROM sessions WHERE id = ?",
+            (session_id,),
+        )
+        if not session_exists:
+            logger.debug(f"Session {session_id} not found in database, skipping state update")
+            return
+
+        sql = """
+        INSERT INTO session_message_state (
+            session_id, last_byte_offset, last_message_index,
+            last_processed_at, updated_at
+        ) VALUES (?, ?, ?, datetime('now'), datetime('now'))
+        ON CONFLICT(session_id) DO UPDATE SET
+            last_byte_offset=excluded.last_byte_offset,
+            last_message_index=excluded.last_message_index,
+            last_processed_at=excluded.last_processed_at,
+            updated_at=excluded.updated_at
+        """
+        await asyncio.to_thread(self.db.execute, sql, (session_id, byte_offset, message_index))
+
+    async def count_messages(self, session_id: str) -> int:
+        """
+        Count messages for a session.
+
+        Args:
+            session_id: Session ID
+
+        Returns:
+            Number of messages
+        """
+        result = await asyncio.to_thread(
+            self.db.fetchone,
+            "SELECT COUNT(*) as count FROM session_messages WHERE session_id = ?",
+            (session_id,),
+        )
+        return result["count"] if result else 0
+
+    async def get_all_counts(self) -> dict[str, int]:
+        """
+        Get message counts for all sessions.
+
+        Returns:
+            Dictionary mapping session_id to count
+        """
+        rows = await asyncio.to_thread(
+            self.db.fetchall,
+            "SELECT session_id, COUNT(*) as count FROM session_messages GROUP BY session_id",
+        )
+        return {row["session_id"]: row["count"] for row in rows}
+
+    async def search_messages(
+        self,
+        query_text: str,
+        limit: int = 20,
+        offset: int = 0,
+        session_id: str | None = None,
+        project_id: str | None = None,
+    ) -> list[dict[str, Any]]:
+        """
+        Search messages using simple text matching.
+
+        Args:
+            query_text: Text to search for
+            limit: Max results
+            offset: Pagination offset
+            session_id: Optional session ID to filter by
+            project_id: Optional project ID to filter by
+
+        Returns:
+            List of matching messages
+        """
+        # Escape LIKE wildcards in query_text
+        escaped_query = query_text.replace("\\", "\\\\").replace("%", "\\%").replace("_", "\\_")
+        sql = "SELECT m.* FROM session_messages m"
+        params: list[Any] = []
+        conditions: list[str] = ["m.content LIKE ? ESCAPE '\\'"]
+        params.append(f"%{escaped_query}%")
+
+        if project_id:
+            sql += " JOIN sessions s ON m.session_id = s.session_id"
+            conditions.append("s.project_id = ?")
+            params.append(project_id)
+
+        if session_id:
+            conditions.append("m.session_id = ?")
+            params.append(session_id)
+
+        sql += " WHERE " + " AND ".join(conditions)
+        sql += " ORDER BY m.timestamp DESC LIMIT ? OFFSET ?"
+        params.extend([limit, offset])
+
+        rows = await asyncio.to_thread(self.db.fetchall, sql, tuple(params))
+        return [dict(row) for row in rows]

gobby/storage/session_tasks.py

@@ -0,0 +1,97 @@
+import logging
+from datetime import UTC, datetime
+from typing import Any, Literal
+
+from gobby.storage.database import DatabaseProtocol
+from gobby.storage.tasks import Task
+
+logger = logging.getLogger(__name__)
+
+SessionTaskAction = Literal["worked_on", "discovered", "mentioned", "closed"]
+
+
+class SessionTaskManager:
+    VALID_ACTIONS = {"worked_on", "discovered", "mentioned", "closed"}
+
+    def __init__(self, db: DatabaseProtocol):
+        self.db = db
+
+    def link_task(
+        self,
+        session_id: str,
+        task_id: str,
+        action: str = "worked_on",
+    ) -> None:
+        """
+        Link a task to a session with a specific action.
+        Actions: worked_on, discovered, mentioned, closed
+        """
+        if action not in self.VALID_ACTIONS:
+            raise ValueError(f"Invalid action '{action}'. Must be one of {self.VALID_ACTIONS}")
+
+        now = datetime.now(UTC).isoformat()
+
+        with self.db.transaction() as conn:
+            # Use INSERT OR IGNORE to handle duplicate links gracefully
+            conn.execute(
+                """
+                INSERT OR IGNORE INTO session_tasks (
+                    session_id, task_id, action, created_at
+                ) VALUES (?, ?, ?, ?)
+                """,
+                (session_id, task_id, action, now),
+            )
+            logger.debug(f"Linked task {task_id} to session {session_id} with action {action}")
+
+    def unlink_task(
+        self,
+        session_id: str,
+        task_id: str,
+        action: str,
+    ) -> None:
+        """Remove a link between a task and a session."""
+        with self.db.transaction() as conn:
+            conn.execute(
+                """
+                DELETE FROM session_tasks
+                WHERE session_id = ? AND task_id = ? AND action = ?
+                """,
+                (session_id, task_id, action),
+            )
+            logger.debug(f"Unlinked task {task_id} from session {session_id} for action {action}")
+
+    def get_session_tasks(self, session_id: str) -> list[dict[str, Any]]:
+        """
+        Get all tasks associated with a session.
+        Returns a list of dicts with task details and the action.
+        """
+        query = """
+        SELECT t.*, st.action as session_action, st.created_at as link_created_at
+        FROM tasks t
+        JOIN session_tasks st ON t.id = st.task_id
+        WHERE st.session_id = ?
+        ORDER BY st.created_at DESC
+        """
+        rows = self.db.fetchall(query, (session_id,))
+
+        results = []
+        for row in rows:
+            task = Task.from_row(row)
+            results.append(
+                {
+                    "task": task,
+                    "action": row["session_action"],
+                    "link_created_at": row["link_created_at"],
+                }
+            )
+        return results
+
+    def get_task_sessions(self, task_id: str) -> list[dict[str, Any]]:
+        """
+        Get all sessions associated with a task.
+        """
+        # Simple query that relies only on session_tasks to minimize dependencies
+        rows = self.db.fetchall(
+            "SELECT * FROM session_tasks WHERE task_id = ? ORDER BY created_at DESC", (task_id,)
+        )
+        return [dict(row) for row in rows]