Mcp server

.github/workflows/python_package.yml

@@ -44,7 +44,12 @@ jobs:
           flake8 . --count --select=E9,F63,F7,F82 --show-source --statistics
           flake8 . --count --exit-zero --max-complexity=10 --max-line-length=127 --statistics
       - name: Test with pytest
-        run: pytest tests/
+        run: pytest tests --ignore=tests/agents
+      - name: Install package with agents requirements
+        run: |
+          python -m pip install .[agents]
+      - name: Test agents with pytest
+        run: pytest tests/agents
   security:
     name: Security Check
     runs-on: ubuntu-latest

.gitignore

@@ -175,4 +175,5 @@ cython_debug/
 
 storage/
 logs/
+observability_data/
 

README.md

@@ -36,6 +36,48 @@ CodeTide is available as a native [**Visual Studio Code extension**](https://mar
 
 ---
 
+## 🖧 CodeTide as an MCP Server
+
+CodeTide now supports acting as an **MCP Server**, enabling seamless integration with AI agents and tools. This feature allows agents to dynamically interact with your codebase and retrieve context efficiently.
+
+#### Why This Helps Agents
+Agents working with codebases often need:
+- **Contextual Understanding**: Retrieve declarations, imports, and references for any part of the code.
+- **Tool Integration**: Use built-in tools to navigate and analyze code.
+
+#### Available Tools
+CodeTide provides the following tools for agents:
+1. **`getContext`**: Retrieve code context for identifiers (e.g., functions, classes).
+2. **`getRepoTree`**: Explore the repository structure.
+
+#### Example: Initializing an LLM with CodeTide
+Here’s a snippet from `agent_tide.py` demonstrating how to initialize an LLM with CodeTide as an MCP server:
+
+```python
+from aicore.llm import Llm, LlmConfig
+from codetide.mcp import codeTideMCPServer
+import os
+
+def init_llm() -> Llm:
+    llm = Llm.from_config(
+        LlmConfig(
+            model="deepseek-chat",
+            provider="deepseek",
+            temperature=0,
+            api_key=os.getenv("DEEPSEEK-API-KEY")
+        )
+    )
+    llm.provider.mcp.add_server(name=codeTideMCPServer.name, parameters=codeTideMCPServer)
+    return llm
+```
+
+This setup allows the LLM to leverage CodeTide’s tools for codebase interactions.
+
+CodeTide can now be used as an MCP (Multi-Code Processor) Server! This allows seamless integration with AI tools and workflows. Below are the tools available:
+The available tools are:
+- **getContext**: Retrieve code context for identifiers.
+- **getRepoTree**: Generate a visual tree representation of the repository.
+
 ## ⚙️ Installation
 
 ### 📦 From PyPI
@@ -399,9 +441,57 @@ Here’s what’s next for CodeTide:
 
 ~~- 🧭 **Handle relative imports** in Python projects  
   → Improve resolution for intra-package navigation.~~
-- 🤖 **Long-term vision**: Release a native **CodeTide Agent**  
-  → Seamless, intelligent context resolution directly integrated into the CodeTide core.  
-  → Unlock **clinical issue detection**, **guided refactors**, and **agent-level navigation**.
+
+---
+
+## 🤖 Agents Module: AgentTide
+
+CodeTide now includes an `agents` module, featuring **AgentTide**—a precision-driven software engineering agent that connects directly to your codebase and executes your requests with full code context.
+
+**AgentTide** leverages CodeTide’s symbolic code understanding to:
+- Retrieve and reason about relevant code context for any request
+- Generate atomic, high-precision patches using strict protocols
+- Apply changes directly to your codebase, with robust validation
+
+### Where to Find It
+- Source: [`codetide/agents/tide/agent.py`](codetide/agents/tide/agent.py)
+
+### What It Does
+AgentTide acts as an autonomous agent that:
+- Connects to your codebase using CodeTide’s parsing and context tools
+- Interacts with users via a conversational interface
+- Identifies relevant files, classes, and functions for any request
+- Generates and applies diff-style patches, ensuring code quality and requirements fidelity
+
+### Example Usage
+To use AgentTide, ensure you have the `aicore` package installed (`pip install codetide[agents]`), then instantiate and run the agent:
+
+```python
+from codetide import CodeTide
+from codetide.agents.tide.agent import AgentTide
+from aicore.llm import Llm, LlmConfig
+import os, asyncio
+
+async def main():
+    tide = await CodeTide.from_path("/path/to/your/repo")
+    llm = Llm.from_config(
+        LlmConfig(
+            model="deepseek-chat",
+            provider="deepseek",
+            temperature=0,
+            api_key=os.getenv("DEEPSEEK-API-KEY")
+        )
+    )
+    agent = AgentTide(llm=llm, tide=tide)
+    await agent.run()
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
+AgentTide will prompt you for requests, retrieve the relevant code context, and generate precise patches to fulfill your requirements.
+
+For more details, see the [agents module source code](codetide/agents/tide/agent.py).
 
 ---
 

codetide/__init__.py

@@ -1,5 +1,5 @@
 from codetide.core.defaults import (
-    DEFAULT_SERIALIZATION_PATH, DEFAULT_MAX_CONCURRENT_TASKS,
+    CODETIDE_ASCII_ART, DEFAULT_SERIALIZATION_PATH, DEFAULT_MAX_CONCURRENT_TASKS,
     DEFAULT_BATCH_SIZE, DEFAULT_CACHED_ELEMENTS_FILE, DEFAULT_CACHED_IDS_FILE,
     LANGUAGE_EXTENSIONS
 )
@@ -17,7 +17,7 @@
 import asyncio
 import pygit2
 import time
-import json
+import orjson
 import os
 
 class CodeTide(BaseModel):
@@ -80,7 +80,7 @@ async def from_path(
 
         codeTide._add_results_to_codebase(results)
         codeTide._resolve_files_dependencies()
-        logger.info(f"CodeTide initialized with {len(results)} files processed in {time.time() - st:.2f}s")
+        logger.info(f"\n{CODETIDE_ASCII_ART}\nInitialized with {len(results)} files processed in {time.time() - st:.2f}s")
 
         return codeTide
 
@@ -90,6 +90,10 @@ def relative_filepaths(self)->List[str]:
             str(filepath.relative_to(self.rootpath)).replace("\\", "/") for filepath in self.files
         ]
 
+    @property
+    def cached_ids(self)->List[str]:
+        return self.codebase.unique_ids+self.relative_filepaths
+
     async def _reset(self):
         self = await self.from_path(self.rootpath)
 
@@ -138,7 +142,7 @@ def serialize(self,
 
         if include_cached_ids:
             cached_ids_path = dir_path / DEFAULT_CACHED_IDS_FILE
-            writeFile(json.dumps(self.codebase.unique_ids+self.relative_filepaths, indent=4), cached_ids_path)
+            writeFile(str(orjson.dumps(self.cached_ids, option=orjson.OPT_INDENT_2)), cached_ids_path)
 
     @classmethod
     def deserialize(cls, filepath :Optional[Union[str, Path]]=DEFAULT_SERIALIZATION_PATH, rootpath :Optional[Union[str, Path]] = None)->"CodeTide":
@@ -158,7 +162,7 @@ def deserialize(cls, filepath :Optional[Union[str, Path]]=DEFAULT_SERIALIZATION_
         if not os.path.exists(filepath):
             raise FileNotFoundError(f"{filepath} is not a valid path")
 
-        kwargs = json.loads(readFile(filepath))
+        kwargs = orjson.loads(readFile(filepath))
         tideInstance = cls(**kwargs)
 
         # dir_path = Path(os.path.split(filepath))[0]
@@ -458,7 +462,7 @@ async def check_for_updates(self,
                     if self.rootpath / newFile.file_path in filepaths
                 ]
                 parser.resolve_inter_files_dependencies(self.codebase, filteredNewFiles)
-                parser.resolve_intra_file_dependencies(filteredNewFiles)
+                parser.resolve_intra_file_dependencies(self.codebase, filteredNewFiles)
 
                 for codeFile in filteredNewFiles:
                     i = changedPaths.get(codeFile.file_path)
@@ -485,36 +489,47 @@ def _precheck_id_is_file(self, unique_ids : List[str])->Dict[Path, str]:
             if self.rootpath / unique_id in self.files
         }
 
-    def get(self, unique_id :Union[str, List[str]], degree :int=1, slim :bool=False, as_string :bool=True, as_list_str :bool=False)->Union[CodeContextStructure, str, List[str]]:
+    def get(
+        self,
+        code_identifiers: Union[str, List[str]],
+        context_depth: int = 1,
+        concise_mode: bool = False,
+        as_string: bool = True,
+        as_string_list: bool = False
+    ) -> Union[CodeContextStructure, str, List[str]]:
         """
-        Retrieve context around code by unique ID(s).
+        Retrieves code context for given identifiers with flexible return formats.
+        Returns None if no matching identifiers are found.
 
         Args:
-            unique_id: Single or list of unique IDs for code entities.
-            degree: Depth of context to fetch.
-            as_string: Whether to return as a single string.
-            as_list_str: Whether to return as list of strings.
+            code_identifiers: One or more code element IDs or file paths to analyze.
+                            Examples: 'package.ClassName', 'dir/module.py:function', ['file.py', 'module.var']
+            context_depth: Number of reference levels to include (1=direct references only)
+            concise_mode: If True, returns minimal docstrings instead of full code (slim=True)
+            as_string: Return as single formatted string (default)
+            as_string_list: Return as list of strings (overrides as_string if True)
 
         Returns:
-            Code context in the requested format.
+            - CodeContextStructure if both format flags are False
+            - Single concatenated string if as_string=True
+            - List of context strings if as_string_list=True
+            - None if no matching identifiers exist
         """
-        if isinstance(unique_id, str):
-            unique_id = [unique_id]
+        if isinstance(code_identifiers, str):
+            code_identifiers = [code_identifiers]
 
-        # Log the incoming request
         logger.info(
-            f"Getting code context - IDs: {unique_id}, "
-            f"degree: {degree}, "
-            f"as_string: {as_string}, "
-            f"as_list_str: {as_list_str}"
+            f"Context request - IDs: {code_identifiers}, "
+            f"Depth: {context_depth}, "
+            f"Formats: string={as_string}, list={as_string_list}"
         )
 
-        requestedFiles = self._precheck_id_is_file(unique_id)
+        requested_files = self._precheck_id_is_file(code_identifiers)
         return self.codebase.get(
-            unique_id=unique_id,
-            degree=degree,
-            slim=slim,
+            unique_id=code_identifiers,
+            degree=context_depth,
+            slim=concise_mode,
             as_string=as_string,
-            as_list_str=as_list_str,
-            preloaded_files=requestedFiles
+            as_list_str=as_string_list,
+            preloaded_files=requested_files
         )

codetide/agents/__init__.py

@@ -0,0 +1,5 @@
+from .tide import AgentTide
+
+__all__ = [
+    "AgentTide"
+]

codetide/agents/tide/__init__.py

@@ -0,0 +1,5 @@
+from .agent import AgentTide
+
+__all__ = [
+    "AgentTide"
+]