TUI improvements

Signed-off-by: Matthew Ballance <matt.ballance@gmail.com>

Author: mballance

README.md

@@ -185,6 +185,7 @@ See documentation for complete import examples and supported formats.
 ## Documentation
 
 - [MCP Server Documentation](MCP_SERVER.md)
+- [Python SQLite Performance Report](PYTHON_SQLITE_PERFORMANCE_REPORT.md)
 - [UCIS Standard](https://www.accellera.org/activities/committees/ucis)
 
 ## License
@@ -196,4 +197,3 @@ Apache 2.0
 - [PyPI](https://pypi.org/project/pyucis/)
 - [GitHub](https://github.com/fvutils/pyucis)
 - [Issue Tracker](https://github.com/fvutils/pyucis/issues)
-

src/ucis/sqlite/schema_manager.py

@@ -88,7 +88,6 @@ def create_schema(conn: sqlite3.Connection):
         )
     """)
 
-    cursor.execute("CREATE INDEX IF NOT EXISTS idx_scopes_parent ON scopes(parent_id)")
     cursor.execute("CREATE INDEX IF NOT EXISTS idx_scopes_parent_type_name ON scopes(parent_id, scope_type, scope_name)")
 
     # 4. Cover Items
@@ -116,7 +115,6 @@ def create_schema(conn: sqlite3.Connection):
         )
     """)
 
-    cursor.execute("CREATE INDEX IF NOT EXISTS idx_coveritems_scope_index ON coveritems(scope_id, cover_index)")
 
     # 5. History Nodes
     cursor.execute("""
@@ -162,7 +160,6 @@ def create_schema(conn: sqlite3.Connection):
         )
     """)
 
-    cursor.execute("CREATE INDEX IF NOT EXISTS idx_coveritem_tests_cover ON coveritem_tests(cover_id)")
     cursor.execute("CREATE INDEX IF NOT EXISTS idx_coveritem_tests_history ON coveritem_tests(history_id)")
 
     # 7. Properties Tables
@@ -512,3 +509,10 @@ def ensure_schema_current(conn: sqlite3.Connection):
             f"Database schema version mismatch: found {version}, expected {SCHEMA_VERSION}. "
             f"Please recreate the database with the current schema version."
         )
+
+    # Remove known redundant indexes to reduce DB size and write overhead
+    cursor = conn.cursor()
+    cursor.execute("DROP INDEX IF EXISTS idx_coveritems_scope_index")
+    cursor.execute("DROP INDEX IF EXISTS idx_scopes_parent")
+    cursor.execute("DROP INDEX IF EXISTS idx_coveritem_tests_cover")
+    conn.commit()

src/ucis/tui/controller.py

@@ -39,6 +39,15 @@ def __init__(self, coverage_model, on_quit: Optional[Callable] = None):
         # Status messages
         self.status_message = ""
         self.status_type = "info"  # "info", "error", "success"
+        self._view_order = [
+            "dashboard",
+            "hierarchy",
+            "gaps",
+            "hotspots",
+            "metrics",
+            "code_coverage",
+            "test_history",
+        ]
 
     def register_view(self, name: str, view):
         """Register a view with the controller."""
@@ -115,6 +124,11 @@ def handle_key(self, key: str) -> bool:
         if self.show_help:
             self.show_help = False
             return True
+
+        # Global page navigation with arrows
+        if key in ("left", "right") and self.current_view_name:
+            if self._switch_adjacent_view(-1 if key == "left" else 1):
+                return True
 
         # Give view first chance to handle key
         current_view = self.get_current_view()
@@ -124,6 +138,19 @@ def handle_key(self, key: str) -> bool:
 
         # If view didn't handle it, try global keys
         return self._handle_global_key(key)
+
+    def _switch_adjacent_view(self, direction: int) -> bool:
+        """Switch to previous/next registered top-level view."""
+        if self.current_view_name not in self._view_order:
+            return False
+
+        available = [v for v in self._view_order if v in self.views]
+        if len(available) < 2:
+            return False
+
+        idx = available.index(self.current_view_name)
+        new_idx = (idx + direction) % len(available)
+        return self.switch_view(available[new_idx])
 
     def _handle_global_key(self, key: str) -> bool:
         """

src/ucis/tui/models/coverage_model.py

@@ -67,7 +67,37 @@ def get_summary(self) -> Dict[str, Any]:
             'by_type': {}
         }
 
-        # Walk through database to compute statistics
+        # Fast path for SQLite backends
+        if self.db and hasattr(self.db, 'conn'):
+            from ucis.cover_type_t import CoverTypeT
+            from ucis.scope_type_t import ScopeTypeT
+            try:
+                conn = self.db.conn
+                summary['covergroups'] = conn.execute(
+                    "SELECT COUNT(*) FROM scopes WHERE (scope_type & ?) != 0",
+                    (int(ScopeTypeT.COVERGROUP),)
+                ).fetchone()[0]
+                summary['coverpoints'] = conn.execute(
+                    "SELECT COUNT(*) FROM scopes WHERE (scope_type & ?) != 0",
+                    (int(ScopeTypeT.COVERPOINT),)
+                ).fetchone()[0]
+                row = conn.execute(
+                    """SELECT COUNT(*),
+                              SUM(CASE WHEN cover_data > 0 THEN 1 ELSE 0 END)
+                       FROM coveritems
+                       WHERE (cover_type & ?) != 0""",
+                    (int(CoverTypeT.CVGBIN),)
+                ).fetchone()
+                summary['total_bins'] = row[0] or 0
+                summary['covered_bins'] = row[1] or 0
+                if summary['total_bins'] > 0:
+                    summary['overall_coverage'] = (summary['covered_bins'] / summary['total_bins']) * 100
+                self._cache['summary'] = summary
+                return summary
+            except Exception:
+                pass
+
+        # Walk through database to compute statistics (fallback)
         def visit_scope(scope, depth=0):
             from ucis.scope_type_t import ScopeTypeT
             from ucis.cover_type_t import CoverTypeT
@@ -125,8 +155,15 @@ def get_database_info(self) -> Dict[str, Any]:
         # Get test data if available
         if self.db:
             try:
-                tests = self.get_all_tests()
-                info['test_count'] = len(tests)
+                if hasattr(self.db, 'conn'):
+                    from ucis.history_node_kind import HistoryNodeKind
+                    info['test_count'] = self.db.conn.execute(
+                        "SELECT COUNT(*) FROM history_nodes WHERE history_kind = ?",
+                        (int(HistoryNodeKind.TEST),)
+                    ).fetchone()[0]
+                else:
+                    tests = self.get_all_tests()
+                    info['test_count'] = len(tests)
             except:
                 pass
 
@@ -147,6 +184,25 @@ def get_coverage_types(self) -> List[CoverTypeT]:
         """
         if 'coverage_types' in self._cache:
             return self._cache['coverage_types']
+
+        # Fast path for SQLite backend
+        if self.db and hasattr(self.db, 'conn'):
+            try:
+                rows = self.db.conn.execute(
+                    "SELECT DISTINCT cover_type FROM coveritems ORDER BY cover_type"
+                ).fetchall()
+                types_list = []
+                for r in rows:
+                    if r[0] is None:
+                        continue
+                    try:
+                        types_list.append(CoverTypeT(r[0]))
+                    except Exception:
+                        pass
+                self._cache['coverage_types'] = types_list
+                return types_list
+            except Exception:
+                pass
 
         types_found: Set[CoverTypeT] = set()
 
@@ -206,6 +262,30 @@ def get_code_coverage_summary(self) -> Dict[str, Any]:
             CoverTypeT.FSMBIN: 'fsm',
             CoverTypeT.BLOCKBIN: 'block',
         }
+
+        # Fast path for SQLite backend
+        if self.db and hasattr(self.db, 'conn'):
+            try:
+                rows = self.db.conn.execute(
+                    """SELECT cover_type,
+                              COUNT(*) AS total,
+                              SUM(CASE WHEN cover_data > 0 THEN 1 ELSE 0 END) AS covered
+                       FROM coveritems
+                       GROUP BY cover_type"""
+                ).fetchall()
+                int_type_map = {int(k): v for k, v in type_map.items()}
+                for row in rows:
+                    key = int_type_map.get(row[0])
+                    if key is not None:
+                        summary[key]['total'] = row[1] or 0
+                        summary[key]['covered'] = row[2] or 0
+                for key in summary:
+                    if summary[key]['total'] > 0:
+                        summary[key]['coverage'] = (summary[key]['covered'] / summary[key]['total']) * 100
+                self._cache['code_coverage_summary'] = summary
+                return summary
+            except Exception:
+                pass
 
         def visit_scope(scope):
             for cov_type, key in type_map.items():
@@ -268,6 +348,37 @@ def get_coverage_by_type(self, cov_type: CoverTypeT, filtered: bool = True) -> D
             'covered': 0,
             'coverage': 0.0
         }
+
+        # Fast path for SQLite backend
+        if self.db and hasattr(self.db, 'conn'):
+            try:
+                if filter_active:
+                    row = self.db.conn.execute(
+                        """SELECT COUNT(*),
+                                  SUM(CASE WHEN ci.cover_data > 0 THEN 1 ELSE 0 END)
+                           FROM coveritems ci
+                           JOIN coveritem_tests ct ON ct.cover_id = ci.cover_id
+                           JOIN history_nodes hn ON hn.history_id = ct.history_id
+                           WHERE (ci.cover_type & ?) != 0
+                             AND hn.logical_name = ?""",
+                        (int(cov_type), self.test_filter)
+                    ).fetchone()
+                else:
+                    row = self.db.conn.execute(
+                        """SELECT COUNT(*),
+                                  SUM(CASE WHEN cover_data > 0 THEN 1 ELSE 0 END)
+                           FROM coveritems
+                           WHERE (cover_type & ?) != 0""",
+                        (int(cov_type),)
+                    ).fetchone()
+                result['total'] = row[0] or 0
+                result['covered'] = row[1] or 0
+                if result['total'] > 0:
+                    result['coverage'] = (result['covered'] / result['total']) * 100
+                self._cache[cache_key] = result
+                return result
+            except Exception:
+                pass
 
         def visit_scope(scope):
             try: