nia-mcp-server 1.0.16__tar.gz → 1.0.21__tar.gz

{nia_mcp_server-1.0.16 → nia_mcp_server-1.0.21}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nia-mcp-server
-Version: 1.0.16
+Version: 1.0.21
 Summary: Nia Knowledge Agent
 Project-URL: Homepage, https://trynia.ai
 Project-URL: Documentation, https://docs.trynia.ai

{nia_mcp_server-1.0.16 → nia_mcp_server-1.0.21}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "nia-mcp-server"
-version = "1.0.16"
+version = "1.0.21"
 description = "Nia Knowledge Agent"
 readme = "README.md"
 requires-python = ">=3.8"

{nia_mcp_server-1.0.16 → nia_mcp_server-1.0.21}/src/nia_mcp_server/__init__.py

@@ -2,4 +2,4 @@
 NIA MCP Server - Proxy server for NIA Knowledge Agent
 """
 
-__version__ = "1.0.16"
+__version__ = "1.0.21"

{nia_mcp_server-1.0.16 → nia_mcp_server-1.0.21}/src/nia_mcp_server/api_client.py

@@ -28,7 +28,7 @@ class NIAApiClient:
         self.client = httpx.AsyncClient(
             headers={
                 "Authorization": f"Bearer {api_key}",
-                "User-Agent": "nia-mcp-server/1.0.0",
+                "User-Agent": "nia-mcp-server/1.0.21",
                 "Content-Type": "application/json"
             },
             timeout=720.0  # 12 minute timeout for deep research operations
@@ -176,7 +176,10 @@ class NIAApiClient:
                     # Regular repo URL - extract owner/repo
                     parts = clean_url.rstrip('/').split('/')
                     if len(parts) >= 2:
-                        repo_name = parts[-1].rstrip('.git')  # Remove .git suffix
+                        repo_name = parts[-1]
+                        # Remove .git suffix if present
+                        if repo_name.endswith('.git'):
+                            repo_name = repo_name[:-4]
                         repository_path = f"{parts[-2]}/{repo_name}"
                     else:
                         repository_path = repo_url
@@ -549,15 +552,23 @@ class NIAApiClient:
                 for repo in repositories:
                     repo_list.append({"repository": repo})
             
-            # Build data source list  
+            # Build data source list
             source_list = []
             if data_sources:
-                for source_id in data_sources:
-                    # Handle both list of IDs and list of dicts
-                    if isinstance(source_id, dict):
-                        source_list.append(source_id)
+                for source in data_sources:
+                    # Handle flexible identifier formats:
+                    # 1. String directly (display_name, URL, or source_id) - NEW
+                    # 2. Dict with "source_id" (backwards compatible)
+                    # 3. Dict with "identifier" (new format)
+                    if isinstance(source, str):
+                        # Pass string directly - backend will resolve it
+                        source_list.append(source)
+                    elif isinstance(source, dict):
+                        # Keep dict format as-is (backwards compatible)
+                        source_list.append(source)
                     else:
-                        source_list.append({"source_id": source_id})
+                        # Convert other types to string
+                        source_list.append(str(source))
             
             # Validate at least one source
             if not repo_list and not source_list:
@@ -685,4 +696,195 @@ class NIAApiClient:
         except httpx.HTTPStatusError as e:
             raise self._handle_api_error(e)
         except Exception as e:
-            raise APIError(f"Failed to get source content: {str(e)}")
+            raise APIError(f"Failed to get source content: {str(e)}")
+    
+    async def index_local_filesystem(
+        self,
+        directory_path: str,
+        inclusion_patterns: List[str] = None,
+        exclusion_patterns: List[str] = None,
+        max_file_size_mb: int = 50
+    ) -> Dict[str, Any]:
+        """Index a local filesystem directory."""
+        try:
+            payload = {
+                "directory_path": directory_path,
+                "inclusion_patterns": inclusion_patterns or [],
+                "exclusion_patterns": exclusion_patterns or [],
+                "max_file_size_mb": max_file_size_mb
+            }
+            
+            response = await self.client.post(
+                f"{self.base_url}/v2/local-filesystem",
+                json=payload
+            )
+            response.raise_for_status()
+            return response.json()
+            
+        except httpx.HTTPStatusError as e:
+            raise self._handle_api_error(e)
+        except Exception as e:
+            raise APIError(f"Failed to index local filesystem: {str(e)}")
+    
+    async def scan_local_filesystem(
+        self,
+        directory_path: str,
+        inclusion_patterns: List[str] = None,
+        exclusion_patterns: List[str] = None,
+        max_file_size_mb: int = 50
+    ) -> Dict[str, Any]:
+        """Scan a local filesystem directory to preview what would be indexed."""
+        try:
+            payload = {
+                "directory_path": directory_path,
+                "inclusion_patterns": inclusion_patterns or [],
+                "exclusion_patterns": exclusion_patterns or [],
+                "max_file_size_mb": max_file_size_mb
+            }
+            
+            response = await self.client.post(
+                f"{self.base_url}/v2/local-filesystem/scan",
+                json=payload
+            )
+            response.raise_for_status()
+            return response.json()
+            
+        except httpx.HTTPStatusError as e:
+            raise self._handle_api_error(e)
+        except Exception as e:
+            raise APIError(f"Failed to scan local filesystem: {str(e)}")
+    
+    async def check_local_filesystem_status(self, source_id: str) -> Dict[str, Any]:
+        """Check the indexing status of a local filesystem source."""
+        try:
+            response = await self.client.get(
+                f"{self.base_url}/v2/local-filesystem/{source_id}"
+            )
+            response.raise_for_status()
+            return response.json()
+            
+        except httpx.HTTPStatusError as e:
+            raise self._handle_api_error(e)
+        except Exception as e:
+            raise APIError(f"Failed to check local filesystem status: {str(e)}")
+
+    # ========================================================================
+    # CHROMA PACKAGE SEARCH METHODS
+    # ========================================================================
+
+    async def package_search_grep(
+        self,
+        registry: str,
+        package_name: str,
+        pattern: str,
+        version: Optional[str] = None,
+        language: Optional[str] = None,
+        filename_sha256: Optional[str] = None,
+        a: Optional[int] = None,
+        b: Optional[int] = None,
+        c: Optional[int] = None,
+        head_limit: Optional[int] = None,
+        output_mode: str = "content"
+    ) -> Dict[str, Any]:
+        """Execute grep search on package source code via Chroma."""
+        try:
+            payload = {
+                "registry": registry,
+                "package_name": package_name,
+                "pattern": pattern,
+                "version": version,
+                "language": language,
+                "filename_sha256": filename_sha256,
+                "a": a,
+                "b": b,
+                "c": c,
+                "head_limit": head_limit,
+                "output_mode": output_mode
+            }
+
+            # Remove None values
+            payload = {k: v for k, v in payload.items() if v is not None}
+
+            response = await self.client.post(
+                f"{self.base_url}/v2/package-search/grep",
+                json=payload
+            )
+            response.raise_for_status()
+            return response.json()
+
+        except httpx.HTTPStatusError as e:
+            raise self._handle_api_error(e)
+        except Exception as e:
+            raise APIError(f"Failed to search package with grep: {str(e)}")
+
+    async def package_search_hybrid(
+        self,
+        registry: str,
+        package_name: str,
+        semantic_queries: List[str],
+        version: Optional[str] = None,
+        filename_sha256: Optional[str] = None,
+        pattern: Optional[str] = None,
+        language: Optional[str] = None
+    ) -> Dict[str, Any]:
+        """Execute hybrid semantic search on package source code via Chroma."""
+        try:
+            payload = {
+                "registry": registry,
+                "package_name": package_name,
+                "semantic_queries": semantic_queries,
+                "version": version,
+                "filename_sha256": filename_sha256,
+                "pattern": pattern,
+                "language": language
+            }
+
+            # Remove None values
+            payload = {k: v for k, v in payload.items() if v is not None}
+
+            response = await self.client.post(
+                f"{self.base_url}/v2/package-search/hybrid",
+                json=payload
+            )
+            response.raise_for_status()
+            return response.json()
+
+        except httpx.HTTPStatusError as e:
+            raise self._handle_api_error(e)
+        except Exception as e:
+            raise APIError(f"Failed to search package with hybrid search: {str(e)}")
+
+    async def package_search_read_file(
+        self,
+        registry: str,
+        package_name: str,
+        filename_sha256: str,
+        start_line: int,
+        end_line: int,
+        version: Optional[str] = None
+    ) -> Dict[str, Any]:
+        """Read specific lines from a package file via Chroma."""
+        try:
+            payload = {
+                "registry": registry,
+                "package_name": package_name,
+                "filename_sha256": filename_sha256,
+                "start_line": start_line,
+                "end_line": end_line,
+                "version": version
+            }
+
+            # Remove None values
+            payload = {k: v for k, v in payload.items() if v is not None}
+
+            response = await self.client.post(
+                f"{self.base_url}/v2/package-search/read-file",
+                json=payload
+            )
+            response.raise_for_status()
+            return response.json()
+
+        except httpx.HTTPStatusError as e:
+            raise self._handle_api_error(e)
+        except Exception as e:
+            raise APIError(f"Failed to read package file: {str(e)}")