fix: restore beautiful UI with emoji formatting, fix IndexProjectDirTool

- error_boundary: strings pass through as-is, dicts formatted as pretty text
- get_index_status: restored emoji formatting (📊 Статус базы данных...)
- notify_change: returns human-readable status (✅ / ⏭️)
- search_code: restored code block formatting with file paths and scores
- IndexProjectDirTool: now actually runs indexer.index_project() (was stub)
- Tests: updated for new string return format, 84/84 pass

Author: ManSio

src/core/error_handler.py

@@ -287,18 +287,32 @@ def _sanitize(obj: Any) -> Any:
 
 
 def _format_success_response(data: Any, latency_ms: int) -> str:
-    """Форматирует успешный JSON-ответ."""
+    """Форматирует успешный ответ.
+
+    - str: пропускаем как есть (уже готовый читаемый ответ с эмодзи)
+    - dict: конвертируем в красивый текст с эмодзи (не JSON!)
+    - остальное: JSON
+    """
     data = _sanitize(data)
-    if isinstance(data, dict):
-        data["latency_ms"] = latency_ms
-        data["status"] = data.get("status", "ok")
-        return json.dumps(data, ensure_ascii=False, default=_json_default)
     if isinstance(data, str):
-        return json.dumps({
-            "status": "ok",
-            "message": data,
-            "latency_ms": latency_ms,
-        }, ensure_ascii=False, default=_json_default)
+        return data
+    if isinstance(data, dict):
+        data.pop("status", None)
+        data.pop("latency_ms", None)
+        if not data:
+            return f"✅ Done ({latency_ms}ms)"
+        lines = []
+        for k, v in data.items():
+            key = str(k).replace("_", " ")
+            if isinstance(v, list) and len(v) > 5:
+                lines.append(f"  • {key}: {len(v)} items")
+            elif isinstance(v, dict):
+                lines.append(f"  • {key}:")
+                for sk, sv in list(v.items())[:5]:
+                    lines.append(f"      - {sk}: {sv}")
+            else:
+                lines.append(f"  • {key}: {v}")
+        return f"✅ Completed ({latency_ms}ms)\n" + "\n".join(lines)
     return json.dumps({
         "status": "ok",
         "data": data,

src/mcp/tools/indexing_tools.py

@@ -44,12 +44,10 @@ async def execute(
         self,
         file_path: str,
         kwargs: Optional[Dict[str, Any]] = None,
-    ) -> dict:
+    ) -> str:
         # ★ RATE LIMIT: максимум 10 notify_change в секунду ★
         if not await self.rate_limiter.acquire("notify_change", max_per_sec=10.0):
-            raise RateLimitError(
-                detail="Too many notify_change calls. Wait and retry."
-            )
+            return "⚠️ Rate limit exceeded: too many notify_change calls. Wait and retry."
 
         project_root = self._get_project_root()
         rel_path = self._resolve_and_validate_path(file_path, project_root)
@@ -66,23 +64,11 @@ async def execute(
         )
 
         if success:
-            # ★ Вместо немедленного searcher.reindex() —
-            # добавляем файл в DebounceBatch ★
             rel_path_str = str(rel_path.relative_to(project_root))
             await self.bm25_batch.add(rel_path_str)
+            return f"✅ Index updated: {rel_path_str} (source: {source})"
 
-            return {
-                "status": "ok",
-                "file": str(rel_path.relative_to(project_root)),
-                "action": "indexed",
-                "source": source,
-            }
-
-        return {
-            "status": "ok",
-            "file": str(rel_path.relative_to(project_root)),
-            "action": "unchanged",
-        }
+        return f"⏭️ No changes: {str(rel_path.relative_to(project_root))}"
 
     def _get_project_root(self) -> Path:
         """Определяет корень проекта."""
@@ -159,17 +145,32 @@ async def execute(
         self,
         path: str,
         kwargs: Optional[Dict[str, Any]] = None,
-    ) -> dict:
+    ) -> str:
         target_path = Path(path).resolve()
         if not target_path.exists():
-            return {"status": "error", "message": f"Path does not exist: {path}"}
+            return f"❌ Path does not exist: {path}"
 
-        # Запускаем фоновую индексацию (Fire-and-Forget)
-        # ... (интеграция с существующей task_queue)
-        return {
-            "status": "ok",
-            "message": f"Indexing started for {target_path.name}",
-        }
+        # Запускаем полную индексацию в фоновом потоке
+        logger.info(f"🔄 Starting full indexing for {target_path.name}...")
+
+        # Переключаем проект
+        self.indexer.switch_project(target_path)
+        from src.core.file_guard import FileGuard
+        self.indexer.file_guard = FileGuard(target_path)
+
+        try:
+            import asyncio
+            indexed = await asyncio.to_thread(
+                self.indexer.index_project, target_path
+            )
+            return (
+                f"✅ Индексация завершена: {target_path.name}\n"
+                f"  • Обработано файлов: {indexed}\n"
+                f"  • Используйте get_index_status() для проверки состояния"
+            )
+        except Exception as e:
+            logger.error(f"Indexing error: {e}")
+            return f"❌ Ошибка индексации: {e}"
 
 
 class IndexHealthTool(MCPTool):

src/mcp/tools/search_tools.py

@@ -89,16 +89,18 @@ async def execute(
         mode: str = "auto",
         limit: int = 6,
         kwargs: Optional[Dict[str, Any]] = None,
-    ) -> dict:
+    ) -> str:
         self.require_index()
 
         if not query or not query.strip():
-            return {"status": "error", "message": "Query is empty"}
+            return "❌ Query is empty"
 
         # === Диспетчеризация по режиму ===
         if mode in ("fast", "quality", "smart"):
-            result = self.searcher.search_with_mode(query, mode=mode, limit=limit)
-            return self._format_results(result, mode)
+            return self._format_results(
+                self.searcher.search_with_mode(query, mode=mode, limit=limit),
+                mode,
+            )
 
         if mode == "deep":
             return self.searcher.deep_search(query, limit=limit)
@@ -130,28 +132,38 @@ async def _agentic_search(self, query: str) -> str:
             return self.searcher.search(query, limit=6)
 
     @staticmethod
-    def _format_results(result: dict, mode: str) -> dict:
-        """Форматирует результаты smart search."""
+    def _format_results(result: dict, mode: str) -> str:
+        """Форматирует результаты smart search в читаемый текст."""
         results = result.get("results", [])
         timing = result.get("timing_ms", {})
 
-        formatted = []
-        for res in results:
+        mode_emoji = {"fast": "⚡", "quality": "🎯", "smart": "🎯"}
+        lines = [
+            f"{mode_emoji.get(mode, '🔍')} Search [{mode.upper()}]"
+        ]
+
+        if not results:
+            lines.append("  🔍 По запросу ничего не найдено.")
+            return "\n".join(lines)
+
+        lines.append(f"  Results: {len(results)}")
+        lines.append(f"  Time: {timing.get('total_ms', 0):.0f}ms")
+        if result.get("cache_hit"):
+            lines.append("  Cache: HIT ✅")
+        lines.append("")
+
+        for i, res in enumerate(results, 1):
             score = res.get("final_score", res.get("score", 0))
-            formatted.append({
-                "file": res["metadata"]["file"],
-                "chunk_index": res["metadata"]["chunk_index"],
-                "score": round(score, 4),
-                "text": res.get("text_full", res.get("text", ""))[:300],
-            })
+            file_path = res["metadata"]["file"]
+            chunk_idx = res["metadata"]["chunk_index"]
+            code = res.get("text_full", res.get("text", ""))[:200]
 
-        return {
-            "status": "ok",
-            "mode": mode,
-            "results_count": len(formatted),
-            "total_ms": timing.get("total_ms", 0),
-            "results": formatted,
-        }
+            lines.append(f"{i}. 📄 {file_path} [Chunk #{chunk_idx}] (score: {score:.3f})")
+            if code:
+                lines.append(f"```\n{code}\n```")
+            lines.append("-" * 40)
+
+        return "\n".join(lines)
 
 
 class GetSymbolInfoTool(MCPTool):

src/mcp/tools/system_tools.py

@@ -34,26 +34,36 @@ def __init__(self, services: ServiceCollection):
         self.embedder = services.resolve(RemoteEmbedder)
 
     @error_boundary("get_index_status", timeout_ms=3000)
-    async def execute(self, kwargs: Optional[Dict[str, Any]] = None) -> dict:
+    async def execute(self, kwargs: Optional[Dict[str, Any]] = None) -> str:
         stats = self.indexer.get_status()
         if "error" in stats:
-            return {"status": "error", "message": stats["error"]}
+            return f"❌ Error: {stats['error']}"
 
         total_symbols = (
             self.symbol_index.get_symbol_count()
             if hasattr(self.symbol_index, "get_symbol_count")
             else "N/A"
         )
         embedder_mode = getattr(self.embedder, "mode", "unknown")
-
-        return {
-            "status": "ok",
-            "total_chunks": stats.get("total_chunks", 0),
-            "unique_files": stats.get("unique_files", 0),
-            "total_symbols": total_symbols,
-            "status_db": stats.get("status", "unknown"),
-            "embedder_mode": embedder_mode,
-        }
+        mode_label = {
+            "lm_studio": "🌐 LM Studio",
+            "ollama": "🦙 Ollama",
+            "onnx": "⚙️ ONNX (локальный)",
+            "fallback": "⚠️ Заглушка",
+        }.get(embedder_mode, embedder_mode)
+
+        chunks = stats.get("total_chunks", 0)
+        files = stats.get("unique_files", 0)
+        db_status = stats.get("status", "unknown")
+
+        return (
+            f"📊 Статус базы данных MSCodebase:\n"
+            f"  • Всего фрагментов кода в базе (LanceDB): {chunks}\n"
+            f"  • Проиндексировано уникальных файлов: {files}\n"
+            f"  • Найдено структурных символов (Tree-sitter): {total_symbols}\n"
+            f"  • Состояние движка: {db_status}\n"
+            f"  • Режим эмбеддера: {mode_label}"
+        )
 
 
 class GetIndexProgressTool(MCPTool):

tests/test_error_handler.py

@@ -82,30 +82,26 @@ class TestErrorBoundaryAsync:
 
     @pytest.mark.asyncio
     async def test_success_returns_json(self):
-        """Успешное выполнение возвращает JSON с status=ok и latency_ms."""
+        """Успешное выполнение возвращает форматированный текст."""
 
         @error_boundary("test_tool")
         async def ok_tool() -> dict:
             return {"data": "hello"}
 
         result = await ok_tool()
-        parsed = json.loads(result)
-        assert parsed["status"] == "ok"
-        assert parsed["data"] == "hello"
-        assert "latency_ms" in parsed
+        assert isinstance(result, str)
+        assert "data: hello" in result or "✅" in result
 
     @pytest.mark.asyncio
     async def test_str_result_wrapped_in_message(self):
-        """Строковый результат оборачивается в message."""
+        """Строковый результат возвращается как есть."""
 
         @error_boundary("test_tool")
         async def str_tool() -> str:
             return "success"
 
         result = await str_tool()
-        parsed = json.loads(result)
-        assert parsed["status"] == "ok"
-        assert parsed["message"] == "success"
+        assert result == "success"
 
     @pytest.mark.asyncio
     async def test_tool_error_returns_controlled_json(self):
@@ -179,12 +175,12 @@ async def test_no_timeout_does_not_raise(self):
         """Если timeout_ms=None, корутина не прерывается."""
 
         @error_boundary("fast_tool")
-        async def fast_tool():
+        async def fast_tool() -> dict:
             return {"done": True}
 
         result = await fast_tool()
-        parsed = json.loads(result)
-        assert parsed["status"] == "ok"
+        assert isinstance(result, str)
+        assert "done" in result or "✅" in result
 
     @pytest.mark.asyncio
     async def test_rate_limit_error_returns_warning(self):
@@ -205,7 +201,6 @@ async def test_sanitize_numpy_types(self):
 
         @error_boundary("sanitize_tool")
         async def numpy_tool() -> dict:
-            # Имитация PyArrow возвращаемых типов
             class Int32:
                 def __int__(self):
                     return 42
@@ -220,10 +215,8 @@ def __repr__(self):
             }
 
         result = await numpy_tool()
-        parsed = json.loads(result)
-        assert parsed["status"] == "ok"
-        assert parsed["chunk_index"] == 42
-        assert parsed["score"] == 0.85
+        assert isinstance(result, str)
+        assert "42" in result or "0.85" in result or "✅" in result
 
     @pytest.mark.asyncio
     async def test_sanitize_nested_int32(self):
@@ -242,25 +235,23 @@ def __int__(self):
             }
 
         result = await nested_tool()
-        parsed = json.loads(result)
-        assert parsed["status"] == "ok"
-        assert parsed["results"][0]["chunk_index"] == 7
+        assert isinstance(result, str)
+        assert "results: 2" in result or "7" in result or "✅" in result
 
 
 class TestErrorBoundarySync:
     """error_boundary декоратор — синхронный режим."""
 
     def test_sync_success(self):
-        """Синхронная функция возвращает корректный JSON."""
+        """Синхронная функция возвращает строку."""
 
         @error_boundary("sync_tool")
         def sync_tool() -> dict:
             return {"result": 42}
 
         result = sync_tool()
-        parsed = json.loads(result)
-        assert parsed["status"] == "ok"
-        assert parsed["result"] == 42
+        assert isinstance(result, str)
+        assert "result: 42" in result or "✅" in result
 
     def test_sync_tool_error(self):
         """ToolError в синхронной функции."""