Update openspace/skill_engine/store.py

openspace/skill_engine/store.py

@@ -795,10 +795,8 @@ class SkillStore:
                 ).fetchall()
             else:
                 rows = conn.execute("SELECT * FROM skill_records").fetchall()
-            result: Dict[str, SkillRecord] = {}
-            for row in rows:
-                rec = self._to_record(conn, row)
-                result[rec.skill_id] = rec
+            records = self._to_records_bulk(conn, rows)
+            result: Dict[str, SkillRecord] = {rec.skill_id: rec for rec in records}
             logger.info(f"Loaded {len(result)} skill records (active_only={active_only})")
             return result
 
@@ -841,7 +839,7 @@ class SkillStore:
                 "ORDER BY lineage_generation ASC",
                 (name,),
             ).fetchall()
-            return [self._to_record(conn, r) for r in rows]
+            return self._to_records_bulk(conn, rows)
 
     @_db_retry()
     def load_by_category(
@@ -864,7 +862,7 @@ class SkillStore:
                     "SELECT * FROM skill_records WHERE category=?",
                     (category.value,),
                 ).fetchall()
-            return [self._to_record(conn, r) for r in rows]
+            return self._to_records_bulk(conn, rows)
 
     @_db_retry()
     def load_analyses(
@@ -1437,6 +1435,116 @@ class SkillStore:
         return analysis_id
 
     # Deserialization
+    def _to_records_bulk(
+        self, conn: sqlite3.Connection, rows: List[sqlite3.Row]
+    ) -> List[SkillRecord]:
+        """Bulk deserialize skill_records rows → List[SkillRecord]."""
+        if not rows:
+            return []
+
+        sids = [r["skill_id"] for r in rows]
+        parents_map = {sid: [] for sid in sids}
+        deps_map = {sid: [] for sid in sids}
+        tags_map = {sid: [] for sid in sids}
+        analyses_map = {sid: [] for sid in sids}
+
+        def chunks(lst, n):
+            for i in range(0, len(lst), n):
+                yield lst[i:i + n]
+
+        for chunk in chunks(sids, 900):
+            placeholders = ",".join(["?"] * len(chunk))
+            
+            # Parents
+            p_rows = conn.execute(
+                f"SELECT skill_id, parent_skill_id FROM skill_lineage_parents WHERE skill_id IN ({placeholders})",
+                chunk,
+            ).fetchall()
+            for pr in p_rows:
+                parents_map[pr["skill_id"]].append(pr["parent_skill_id"])
+
+            # Tool deps
+            d_rows = conn.execute(
+                f"SELECT skill_id, tool_key, critical FROM skill_tool_deps WHERE skill_id IN ({placeholders})",
+                chunk,
+            ).fetchall()
+            for dr in d_rows:
+                deps_map[dr["skill_id"]].append(dr)
+
+            # Tags
+            t_rows = conn.execute(
+                f"SELECT skill_id, tag FROM skill_tags WHERE skill_id IN ({placeholders})",
+                chunk,
+            ).fetchall()
+            for tr in t_rows:
+                tags_map[tr["skill_id"]].append(tr["tag"])
+
+            # Analyses
+            a_rows = conn.execute(
+                f"""
+                SELECT ea.*, sj.skill_id as sj_skill_id
+                FROM execution_analyses ea
+                JOIN skill_judgments sj ON ea.id = sj.analysis_id
+                WHERE sj.skill_id IN ({placeholders})
+                ORDER BY ea.timestamp DESC
+                """,
+                chunk,
+            ).fetchall()
+            for ar in a_rows:
+                sid = ar["sj_skill_id"]
+                if len(analyses_map[sid]) < SkillRecord.MAX_RECENT:
+                    analyses_map[sid].append(self._to_analysis(conn, ar))
+
+        result = []
+        for row in rows:
+            sid = row["skill_id"]
+            
+            raw_snapshot = row["lineage_content_snapshot"] or "{}"
+            snapshot: Dict[str, str] = json.loads(raw_snapshot)
+            
+            lineage = SkillLineage(
+                origin=SkillOrigin(row["lineage_origin"]),
+                generation=row["lineage_generation"],
+                parent_skill_ids=parents_map[sid],
+                source_task_id=row["lineage_source_task_id"],
+                change_summary=row["lineage_change_summary"],
+                content_diff=row["lineage_content_diff"],
+                content_snapshot=snapshot,
+                created_at=datetime.fromisoformat(row["lineage_created_at"]),
+                created_by=row["lineage_created_by"],
+            )
+            
+            deps = deps_map[sid]
+            record = SkillRecord(
+                skill_id=sid,
+                name=row["name"],
+                description=row["description"],
+                path=row["path"],
+                is_active=bool(row["is_active"]),
+                category=SkillCategory(row["category"]),
+                tags=tags_map[sid],
+                visibility=(
+                    SkillVisibility(row["visibility"])
+                    if row["visibility"] else SkillVisibility.PRIVATE
+                ),
+                creator_id=row["creator_id"] or "",
+                lineage=lineage,
+                tool_dependencies=[r["tool_key"] for r in deps],
+                critical_tools=[
+                    r["tool_key"] for r in deps if r["critical"]
+                ],
+                total_selections=row["total_selections"],
+                total_applied=row["total_applied"],
+                total_completions=row["total_completions"],
+                total_fallbacks=row["total_fallbacks"],
+                recent_analyses=analyses_map[sid],
+                first_seen=datetime.fromisoformat(row["first_seen"]),
+                last_updated=datetime.fromisoformat(row["last_updated"]),
+            )
+            result.append(record)
+            
+        return result
+
     def _to_record(
         self, conn: sqlite3.Connection, row: sqlite3.Row
     ) -> SkillRecord: