fix: resolve Code Quality CI failure with comprehensive formatting fixes

Apply ruff formatting to resolve CI format check failures:
- Fix formatting for 12 files that needed reformatting
- Ensure consistent code style across entire codebase
- Address specific CI Code Quality job failure at line 82 in workflow

Root cause: CI was failing on format-check step, not lint step
Resolution: Applied ruff format to standardize code formatting

All CI Quality checks now pass locally:
✅ Lint: F,E9 violations check clean
✅ Format: All 29 files properly formatted
✅ Type check: mypy validation clean

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <[email protected]>

Author: MementoRC

src/uckn/bridge/unified_interface.py

@@ -38,7 +38,7 @@ class UnifiedKnowledgeManager:
         "session_analysis",
         "enhanced_indexing",
         "backup_restore",
-        "performance_monitoring"
+        "performance_monitoring",
     ]
 
     def __init__(self, knowledge_dir: str = ".uckn/knowledge"):
@@ -55,11 +55,13 @@ def _create_feature_template(self) -> FlagConfigurationTemplate:
         """Create feature flag template for knowledge management capabilities."""
         template = FlagConfigurationTemplate()
         for capability in self.KNOWN_CAPABILITIES:
-            template.add_component(AtomicComponent(
-                name=f"enable_{capability}",
-                level=TemplateLevel.ATOM,
-                config={"default": True, "type": "boolean"}
-            ))
+            template.add_component(
+                AtomicComponent(
+                    name=f"enable_{capability}",
+                    level=TemplateLevel.ATOM,
+                    config={"default": True, "type": "boolean"},
+                )
+            )
         return template
 
     def set_flag(self, flag_name: str, value: bool) -> None:
@@ -93,16 +95,22 @@ def add_knowledge_pattern(self, pattern_data: dict[str, Any]) -> str | None:
             self._logger.error(f"Failed to add knowledge pattern: {e}")
             return None
 
-    def search_patterns(self, query: str, limit: int = 10,
-                       min_similarity: float = 0.7,
-                       metadata_filter: dict[str, Any] | None = None) -> list[dict[str, Any]]:
+    def search_patterns(
+        self,
+        query: str,
+        limit: int = 10,
+        min_similarity: float = 0.7,
+        metadata_filter: dict[str, Any] | None = None,
+    ) -> list[dict[str, Any]]:
         """Search knowledge patterns with feature-controlled capabilities."""
         try:
             capabilities = self.get_capabilities()
             if not capabilities.get("semantic_search", True):
                 self._logger.info("Semantic search disabled by feature flag")
                 return []
-            return self._knowledge_manager.search_patterns(query, limit, min_similarity, metadata_filter)
+            return self._knowledge_manager.search_patterns(
+                query, limit, min_similarity, metadata_filter
+            )
         except Exception as e:
             self._logger.error(f"Pattern search failed: {e}")
             return []
@@ -119,7 +127,9 @@ def get_pattern(self, pattern_id: str) -> dict[str, Any] | None:
             self._logger.error(f"Pattern retrieval failed: {e}")
             return None
 
-    def search_error_solutions(self, error_query: str, limit: int = 5) -> list[dict[str, Any]]:
+    def search_error_solutions(
+        self, error_query: str, limit: int = 5
+    ) -> list[dict[str, Any]]:
         """Search for error solutions with feature gating."""
         capabilities = self.get_capabilities()
         if not capabilities.get("session_analysis", True):
@@ -139,7 +149,10 @@ def backup_knowledge_base(self, backup_path: str) -> bool:
             return False
         try:
             import shutil
-            shutil.copytree(self._knowledge_manager.knowledge_dir, backup_path, dirs_exist_ok=True)
+
+            shutil.copytree(
+                self._knowledge_manager.knowledge_dir, backup_path, dirs_exist_ok=True
+            )
             return True
         except Exception as e:
             self._logger.error(f"Backup failed: {e}")
@@ -154,7 +167,7 @@ def get_performance_metrics(self) -> dict[str, Any]:
             return {
                 "knowledge_base_size": self._get_knowledge_base_size(),
                 "chromadb_available": self._knowledge_manager.chroma_connector.is_available(),
-                "semantic_search_available": self._knowledge_manager.semantic_search.is_available()
+                "semantic_search_available": self._knowledge_manager.semantic_search.is_available(),
             }
         except Exception as e:
             self._logger.error(f"Performance metrics failed: {e}")
@@ -164,7 +177,9 @@ def _get_knowledge_base_size(self) -> int:
         """Get approximate knowledge base size."""
         try:
             knowledge_path = Path(self._knowledge_manager.knowledge_dir)
-            total_size = sum(f.stat().st_size for f in knowledge_path.rglob('*') if f.is_file())
+            total_size = sum(
+                f.stat().st_size for f in knowledge_path.rglob("*") if f.is_file()
+            )
             return total_size
         except Exception:
             return 0
@@ -178,5 +193,5 @@ def get_health_status(self) -> dict[str, Any]:
             "active_features": sum(1 for v in capabilities.values() if v),
             "total_features": len(capabilities),
             "feature_template": self._feature_template.compose_template(),
-            "feature_flags": self._feature_flags.copy()
+            "feature_flags": self._feature_flags.copy(),
         }

src/uckn/core.py

@@ -9,6 +9,7 @@
 # Check for sentence transformers availability
 try:
     import sentence_transformers  # noqa: F401
+
     SENTENCE_TRANSFORMERS_AVAILABLE = True
 except ImportError:
     SENTENCE_TRANSFORMERS_AVAILABLE = False

src/uckn/core/atoms/semantic_search.py

@@ -8,12 +8,12 @@
 
 try:
     from ..semantic_search import SemanticSearchEngine
+
     SEMANTIC_SEARCH_ENGINE_AVAILABLE = True
     SearchEngineClass: type[Any] | None = SemanticSearchEngine
 except ImportError:
     logging.getLogger(__name__).warning(
-        "SemanticSearchEngine not found. "
-        "Semantic search capabilities will be limited."
+        "SemanticSearchEngine not found. Semantic search capabilities will be limited."
     )
     SEMANTIC_SEARCH_ENGINE_AVAILABLE = False
     SearchEngineClass = None
@@ -26,26 +26,33 @@ class SemanticSearch:
 
     def __init__(self, knowledge_dir: str = ".uckn/knowledge"):
         from pathlib import Path
+
         self._logger = logging.getLogger(__name__)
         self.knowledge_dir = Path(knowledge_dir)
         self.engine: Any | None = None
         if SEMANTIC_SEARCH_ENGINE_AVAILABLE and SearchEngineClass:
             self.engine = SearchEngineClass(knowledge_dir=knowledge_dir)
         else:
-            self._logger.warning("SemanticSearchEngine not available, semantic encoding/search will be disabled.")
+            self._logger.warning(
+                "SemanticSearchEngine not available, semantic encoding/search will be disabled."
+            )
 
     @property
     def embeddings_dir(self) -> Path:
         """Expose embeddings_dir from underlying engine."""
-        if self.engine and hasattr(self.engine, 'embeddings_dir'):
+        if self.engine and hasattr(self.engine, "embeddings_dir"):
             return self.engine.embeddings_dir
         return Path(self.knowledge_dir) / "embeddings"
 
     def is_available(self) -> bool:
         """Check if the underlying semantic search engine is available."""
         # Check if dependencies are available dynamically (for test patching)
         import uckn.core
-        if hasattr(uckn.core, 'SENTENCE_TRANSFORMERS_AVAILABLE') and not uckn.core.SENTENCE_TRANSFORMERS_AVAILABLE:
+
+        if (
+            hasattr(uckn.core, "SENTENCE_TRANSFORMERS_AVAILABLE")
+            and not uckn.core.SENTENCE_TRANSFORMERS_AVAILABLE
+        ):
             return False
         return self.engine is not None and self.engine.is_available()
 
@@ -54,29 +61,47 @@ def encode(self, text: str) -> list[float] | None:
         Generate embeddings for text using the underlying sentence transformer model.
         """
         if not self.is_available():
-            self._logger.warning("Semantic search engine not available, cannot encode text.")
+            self._logger.warning(
+                "Semantic search engine not available, cannot encode text."
+            )
             return None
         try:
             # The engine's generate_session_embedding expects a dict, but we just need encode
             # We can directly access the model if it's loaded.
-            if self.engine and hasattr(self.engine, 'sentence_model') and self.engine.sentence_model:
-                embedding = self.engine.sentence_model.encode(text, convert_to_numpy=True)
+            if (
+                self.engine
+                and hasattr(self.engine, "sentence_model")
+                and self.engine.sentence_model
+            ):
+                embedding = self.engine.sentence_model.encode(
+                    text, convert_to_numpy=True
+                )
                 return embedding.tolist()
             else:
-                self._logger.error("Sentence transformer model not loaded in SemanticSearchEngine.")
+                self._logger.error(
+                    "Sentence transformer model not loaded in SemanticSearchEngine."
+                )
                 return None
         except Exception as e:
             self._logger.error(f"Failed to encode text: {e}")
             return None
 
-    def search(self, query: str, collection_name: str, limit: int = 10, min_similarity: float = 0.7) -> list[dict[str, Any]]:
+    def search(
+        self,
+        query: str,
+        collection_name: str,
+        limit: int = 10,
+        min_similarity: float = 0.7,
+    ) -> list[dict[str, Any]]:
         """
         Perform semantic search using the underlying engine's capabilities.
         Note: This method is primarily for direct semantic search on raw text.
         For searching stored patterns, KnowledgeManager's search_patterns should be used.
         """
         if not self.is_available():
-            self._logger.warning("Semantic search engine not available, cannot perform search.")
+            self._logger.warning(
+                "Semantic search engine not available, cannot perform search."
+            )
             return []
         try:
             # SemanticSearchEngine.search_similar_sessions is designed for session data.
@@ -85,7 +110,9 @@ def search(self, query: str, collection_name: str, limit: int = 10, min_similari
             # This method might be redundant if KnowledgeManager handles all searches.
             # For now, let's make it delegate to the engine's search if possible,
             # or indicate it's not the primary search interface.
-            self._logger.info(f"Performing semantic search for query: '{query}' in collection '{collection_name}'")
+            self._logger.info(
+                f"Performing semantic search for query: '{query}' in collection '{collection_name}'"
+            )
             # The SemanticSearchEngine's search_similar_sessions expects a query string
             # and searches its 'session_embeddings' collection.
             # To search other collections, we'd need direct ChromaDB access.
@@ -98,50 +125,69 @@ def search(self, query: str, collection_name: str, limit: int = 10, min_similari
                 "SemanticSearch.search is a placeholder. "
                 "Use KnowledgeManager.search_patterns for searching stored knowledge."
             )
-            return [] # This method is not directly used for stored patterns search by KM.
+            return []  # This method is not directly used for stored patterns search by KM.
         except Exception as e:
             self._logger.error(f"Semantic search failed: {e}")
             return []
 
     def _extract_text_for_embedding(self, session_data: dict[str, Any]) -> str:
         """Extract meaningful text content from session data for embedding."""
         if not self.engine:
-            self._logger.warning("Semantic search engine not available, cannot extract text.")
+            self._logger.warning(
+                "Semantic search engine not available, cannot extract text."
+            )
             return ""
         return self.engine._extract_text_for_embedding(session_data)
 
     def get_embedding_stats(self) -> dict[str, Any]:
         """Get statistics about stored embeddings."""
         if not self.engine:
-            self._logger.warning("Semantic search engine not available, cannot get stats.")
+            self._logger.warning(
+                "Semantic search engine not available, cannot get stats."
+            )
             return {
                 "total_embeddings": 0,
                 "storage_type": "none",
-                "model_available": False
+                "model_available": False,
             }
         return self.engine.get_embedding_stats()
 
-    def search_similar_sessions(self, query: str, max_results: int = 10,
-                              similarity_threshold: float = 0.7) -> list[dict[str, Any]]:
+    def search_similar_sessions(
+        self, query: str, max_results: int = 10, similarity_threshold: float = 0.7
+    ) -> list[dict[str, Any]]:
         """Search for similar sessions using semantic similarity."""
         if not self.engine:
-            self._logger.warning("Semantic search engine not available, cannot search sessions.")
+            self._logger.warning(
+                "Semantic search engine not available, cannot search sessions."
+            )
             return []
-        return self.engine.search_similar_sessions(query, max_results, similarity_threshold)
+        return self.engine.search_similar_sessions(
+            query, max_results, similarity_threshold
+        )
 
-    def store_session_embedding(self, session_id: str, session_data: dict[str, Any]) -> bool:
+    def store_session_embedding(
+        self, session_id: str, session_data: dict[str, Any]
+    ) -> bool:
         """Store session embedding in vector database."""
         if not self.engine:
-            self._logger.warning("Semantic search engine not available, cannot store embedding.")
+            self._logger.warning(
+                "Semantic search engine not available, cannot store embedding."
+            )
             return False
         return self.engine.store_session_embedding(session_id, session_data)
 
-    def _store_embedding_numpy(self, session_id: str, embedding: Any, session_data: dict[str, Any]) -> None:
+    def _store_embedding_numpy(
+        self, session_id: str, embedding: Any, session_data: dict[str, Any]
+    ) -> None:
         """Store embedding using numpy fallback."""
         if not self.engine:
-            self._logger.warning("Semantic search engine not available, cannot store embedding.")
+            self._logger.warning(
+                "Semantic search engine not available, cannot store embedding."
+            )
             return
-        if hasattr(self.engine, '_store_embedding_numpy'):
-            return self.engine._store_embedding_numpy(session_id, embedding, session_data)
+        if hasattr(self.engine, "_store_embedding_numpy"):
+            return self.engine._store_embedding_numpy(
+                session_id, embedding, session_data
+            )
         else:
             self._logger.warning("Numpy storage not available in underlying engine.")

src/uckn/core/atoms/tech_stack_detector.py

@@ -18,7 +18,7 @@ def analyze_project(self, project_path: str) -> dict[str, Any]:
             "package_managers": [],
             "frameworks": [],
             "testing": [],
-            "ci_cd": []
+            "ci_cd": [],
         }
 
         # Detect Python