gobby 0.2.5__py3-none-any.whl → 0.2.7__py3-none-any.whl

gobby/storage/sessions.py

@@ -47,10 +47,13 @@ class Session:
     usage_cache_creation_tokens: int = 0
     usage_cache_read_tokens: int = 0
     usage_total_cost_usd: float = 0.0
+    model: str | None = None  # LLM model used (e.g., "claude-3-5-sonnet-20241022")
     # Terminal context (JSON blob with tty, parent_pid, term_session_id, etc.)
     terminal_context: dict[str, Any] | None = None
     # Global sequence number
     seq_num: int | None = None
+    # Edit history tracking
+    had_edits: bool = False
 
     @classmethod
     def from_row(cls, row: Any) -> Session:
@@ -82,8 +85,10 @@ class Session:
             usage_cache_creation_tokens=row["usage_cache_creation_tokens"] or 0,
             usage_cache_read_tokens=row["usage_cache_read_tokens"] or 0,
             usage_total_cost_usd=row["usage_total_cost_usd"] or 0.0,
+            model=row["model"] if "model" in row.keys() else None,
             terminal_context=cls._parse_terminal_context(row["terminal_context"]),
             seq_num=row["seq_num"] if "seq_num" in row.keys() else None,
+            had_edits=bool(row["had_edits"]) if "had_edits" in row.keys() else False,
         )
 
     @classmethod
@@ -133,6 +138,7 @@ class Session:
             "usage_cache_read_tokens": self.usage_cache_read_tokens,
             "usage_total_cost_usd": self.usage_total_cost_usd,
             "terminal_context": self.terminal_context,
+            "had_edits": self.had_edits,
             "created_at": self.created_at,
             "updated_at": self.updated_at,
             "seq_num": self.seq_num,
@@ -222,8 +228,11 @@ class LocalSessionManager:
         max_retries = 3
         for attempt in range(max_retries):
             try:
-                # Get next seq_num (global)
-                max_seq_row = self.db.fetchone("SELECT MAX(seq_num) as max_seq FROM sessions")
+                # Get next seq_num (per-project)
+                max_seq_row = self.db.fetchone(
+                    "SELECT MAX(seq_num) as max_seq FROM sessions WHERE project_id = ?",
+                    (project_id,),
+                )
                 next_seq_num = ((max_seq_row["max_seq"] if max_seq_row else None) or 0) + 1
 
                 self.db.execute(
@@ -232,9 +241,9 @@ class LocalSessionManager:
                         id, external_id, machine_id, source, project_id, title,
                         jsonl_path, git_branch, parent_session_id,
                         agent_depth, spawned_by_agent_id, terminal_context,
-                        status, created_at, updated_at, seq_num
+                        status, created_at, updated_at, seq_num, had_edits
                     )
-                    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 'active', ?, ?, ?)
+                    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 'active', ?, ?, ?, 0)
                     """,
                     (
                         session_id,
@@ -277,18 +286,20 @@ class LocalSessionManager:
         row = self.db.fetchone("SELECT * FROM sessions WHERE id = ?", (session_id,))
         return Session.from_row(row) if row else None
 
-    def resolve_session_reference(self, ref: str) -> str:
+    def resolve_session_reference(self, ref: str, project_id: str | None = None) -> str:
         """
         Resolve a session reference to a UUID.
 
         Supports:
-        - #N: Global Sequence Number (e.g., #1)
+        - #N: Project-scoped Sequence Number (e.g., #1) - requires project_id
         - N: Integer string treated as #N (e.g., "1")
         - UUID: Full UUID
         - Prefix: UUID prefix (must be unambiguous)
 
         Args:
             ref: Session reference string
+            project_id: Project ID for project-scoped #N lookup.
+                If not provided, falls back to global lookup for backwards compat.
 
         Returns:
             Resolved Session UUID
@@ -306,7 +317,15 @@ class LocalSessionManager:
 
         if seq_num_ref.isdigit():
             seq_num = int(seq_num_ref)
-            row = self.db.fetchone("SELECT id FROM sessions WHERE seq_num = ?", (seq_num,))
+            if project_id:
+                # Project-scoped lookup
+                row = self.db.fetchone(
+                    "SELECT id FROM sessions WHERE project_id = ? AND seq_num = ?",
+                    (project_id, seq_num),
+                )
+            else:
+                # Fallback to global lookup for backwards compat
+                row = self.db.fetchone("SELECT id FROM sessions WHERE seq_num = ?", (seq_num,))
             if not row:
                 raise ValueError(f"Session #{seq_num} not found")
             return str(row["id"])
@@ -424,6 +443,15 @@ class LocalSessionManager:
         )
         return self.get(session_id)
 
+    def mark_had_edits(self, session_id: str) -> Session | None:
+        """Mark session as having edits."""
+        now = datetime.now(UTC).isoformat()
+        self.db.execute(
+            "UPDATE sessions SET had_edits = 1, updated_at = ? WHERE id = ?",
+            (now, session_id),
+        )
+        return self.get(session_id)
+
     def update_title(self, session_id: str, title: str) -> Session | None:
         """Update session title."""
         now = datetime.now(UTC).isoformat()
@@ -433,6 +461,16 @@ class LocalSessionManager:
         )
         return self.get(session_id)
 
+    def update_model(self, session_id: str, model: str) -> Session | None:
+        """Update session model (LLM model used)."""
+        now = datetime.now(UTC).isoformat()
+        with self.db.transaction():
+            self.db.execute(
+                "UPDATE sessions SET model = ?, updated_at = ? WHERE id = ?",
+                (model, now, session_id),
+            )
+        return self.get(session_id)
+
     def update_summary(
         self,
         session_id: str,
@@ -773,6 +811,77 @@ class LocalSessionManager:
             logger.error(f"Failed to update session usage {session_id}: {e}")
             return False
 
+    def add_cost(self, session_id: str, cost_usd: float) -> bool:
+        """
+        Add cost to the session's usage_total_cost_usd.
+
+        This is used for internal agent runs that track cost via CostInfo.
+        Unlike update_usage which overwrites, this method adds to the existing cost.
+
+        Args:
+            session_id: Session ID to update.
+            cost_usd: Cost in USD to add.
+
+        Returns:
+            True if update succeeded, False otherwise.
+        """
+        if cost_usd <= 0:
+            return True  # Nothing to add
+
+        query = """
+        UPDATE sessions
+        SET
+            usage_total_cost_usd = COALESCE(usage_total_cost_usd, 0) + ?,
+            updated_at = datetime('now')
+        WHERE id = ?
+        """
+        try:
+            with self.db.transaction():
+                cursor = self.db.execute(query, (cost_usd, session_id))
+                return cursor.rowcount > 0
+        except Exception as e:
+            logger.error(f"Failed to add cost to session {session_id}: {e}")
+            return False
+
+    def get_sessions_since(
+        self, since: datetime, project_id: str | None = None
+    ) -> builtins.list[Session]:
+        """
+        Get sessions created since a given timestamp.
+
+        Used for aggregating usage over a time period (e.g., daily budget tracking).
+
+        Args:
+            since: Datetime to query from (sessions created after this time)
+            project_id: Optional project ID to filter by
+
+        Returns:
+            List of sessions created since the given timestamp
+        """
+        since_str = since.isoformat()
+
+        if project_id:
+            rows = self.db.fetchall(
+                """
+                SELECT * FROM sessions
+                WHERE created_at >= ?
+                AND project_id = ?
+                ORDER BY created_at DESC
+                """,
+                (since_str, project_id),
+            )
+        else:
+            rows = self.db.fetchall(
+                """
+                SELECT * FROM sessions
+                WHERE created_at >= ?
+                ORDER BY created_at DESC
+                """,
+                (since_str,),
+            )
+
+        return [Session.from_row(row) for row in rows]
+
     def update_terminal_pickup_metadata(
         self,
         session_id: str,