nia-mcp-server 1.0.16__py3-none-any.whl → 1.0.17__py3-none-any.whl

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.17"

nia_mcp_server/api_client.py

@@ -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
@@ -685,4 +688,74 @@ 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)}")

nia_mcp_server/server.py

@@ -1622,6 +1622,408 @@ async def read_source_content(
             text=f"❌ Error reading source content: {str(e)}"
         )]
 
+@mcp.tool()
+async def index_local_filesystem(
+    directory_path: str,
+    inclusion_patterns: Optional[List[str]] = None,
+    exclusion_patterns: Optional[List[str]] = None,
+    max_file_size_mb: int = 50
+) -> List[TextContent]:
+    """
+    Index a local filesystem directory for intelligent search.
+    
+    Args:
+        directory_path: Absolute path to the directory to index
+        inclusion_patterns: Optional list of patterns to include (e.g., ["ext:.py", "dir:src"])
+        exclusion_patterns: Optional list of patterns to exclude (e.g., ["dir:node_modules", "ext:.log"])
+        max_file_size_mb: Maximum file size in MB to process (default: 50)
+        
+    Returns:
+        Status of the indexing operation
+    
+    Important:
+        - Path must be absolute (e.g., /Users/username/projects/myproject)
+        - When indexing starts, use check_local_filesystem_status tool to monitor progress
+    """
+    try:
+        # Validate absolute path
+        if not os.path.isabs(directory_path):
+            return [TextContent(
+                type="text",
+                text=f"❌ Error: directory_path must be an absolute path. Got: {directory_path}\n\n"
+                     f"Example: /Users/username/projects/myproject"
+            )]
+        
+        client = await ensure_api_client()
+        
+        # Start indexing
+        logger.info(f"Starting to index local directory: {directory_path}")
+        result = await client.index_local_filesystem(
+            directory_path=directory_path,
+            inclusion_patterns=inclusion_patterns or [],
+            exclusion_patterns=exclusion_patterns or [],
+            max_file_size_mb=max_file_size_mb
+        )
+        
+        if result.get("success"):
+            source_id = result["data"]["source_id"]
+            status_url = result["data"]["status_url"]
+            
+            return [TextContent(
+                type="text",
+                text=(
+                    f"✅ Successfully started indexing local directory!\n\n"
+                    f"📁 **Directory:** `{directory_path}`\n"
+                    f"🆔 **Source ID:** `{source_id}`\n"
+                    f"📊 **Status:** Processing\n\n"
+                    f"**What happens next:**\n"
+                    f"• NIA is scanning and indexing your files in the background\n"
+                    f"• This process typically takes a few minutes depending on directory size\n"
+                    f"• Use `check_local_filesystem_status` with source ID `{source_id}` to monitor progress\n"
+                    f"• Once indexed, use `search_codebase` or `search_documentation` to search your files\n\n"
+                    f"📌 **Tip:** You can check the status at any time or visit [app.trynia.ai](https://app.trynia.ai) to monitor progress."
+                )
+            )]
+        else:
+            return [TextContent(
+                type="text",
+                text=f"❌ Failed to start indexing: {result.get('detail', 'Unknown error')}"
+            )]
+            
+    except APIError as e:
+        logger.error(f"API error indexing local filesystem: {e}")
+        return [TextContent(
+            type="text",
+            text=f"❌ API Error: {str(e)}\n\nStatus Code: {e.status_code}\nDetails: {e.detail}"
+        )]
+    except Exception as e:
+        logger.error(f"Unexpected error indexing local filesystem: {e}")
+        return [TextContent(
+            type="text",
+            text=f"❌ Error: An unexpected error occurred while indexing the directory: {str(e)}"
+        )]
+
+@mcp.tool()
+async def scan_local_filesystem(
+    directory_path: str,
+    inclusion_patterns: Optional[List[str]] = None,
+    exclusion_patterns: Optional[List[str]] = None,
+    max_file_size_mb: int = 50
+) -> List[TextContent]:
+    """
+    Scan a local filesystem directory to preview what files would be indexed.
+    
+    This tool helps you understand what files will be processed before actually indexing.
+    
+    Args:
+        directory_path: Absolute path to the directory to scan
+        inclusion_patterns: Optional list of patterns to include (e.g., ["ext:.py", "dir:src"])
+        exclusion_patterns: Optional list of patterns to exclude (e.g., ["dir:node_modules", "ext:.log"])
+        max_file_size_mb: Maximum file size in MB to process (default: 50)
+        
+    Returns:
+        Summary of files that would be indexed including count, size, and file types
+    """
+    try:
+        # Validate absolute path
+        if not os.path.isabs(directory_path):
+            return [TextContent(
+                type="text",
+                text=f"❌ Error: directory_path must be an absolute path. Got: {directory_path}\n\n"
+                     f"Example: /Users/username/projects/myproject"
+            )]
+        
+        client = await ensure_api_client()
+        
+        logger.info(f"Scanning local directory: {directory_path}")
+        result = await client.scan_local_filesystem(
+            directory_path=directory_path,
+            inclusion_patterns=inclusion_patterns or [],
+            exclusion_patterns=exclusion_patterns or [],
+            max_file_size_mb=max_file_size_mb
+        )
+        
+        # Format the scan results
+        total_files = result.get("total_files", 0)
+        total_size_mb = result.get("total_size_mb", 0)
+        file_types = result.get("file_types", {})
+        files = result.get("files", [])
+        truncated = result.get("truncated", False)
+        
+        response = f"📊 **Local Directory Scan Results**\n\n"
+        response += f"📁 **Directory:** `{directory_path}`\n"
+        response += f"📄 **Total Files:** {total_files:,}\n"
+        response += f"💾 **Total Size:** {total_size_mb:.2f} MB\n\n"
+        
+        if file_types:
+            response += "**File Types:**\n"
+            # Sort by count descending
+            sorted_types = sorted(file_types.items(), key=lambda x: x[1], reverse=True)
+            for ext, count in sorted_types[:10]:  # Show top 10
+                response += f"• `{ext}`: {count:,} files\n"
+            if len(sorted_types) > 10:
+                response += f"• ... and {len(sorted_types) - 10} more types\n"
+            response += "\n"
+        
+        if files:
+            response += f"**Largest Files (showing {min(len(files), 10)}):**\n"
+            for i, file_info in enumerate(files[:10]):
+                size_mb = file_info["size"] / (1024 * 1024)
+                response += f"{i+1}. `{file_info['path']}` ({size_mb:.2f} MB)\n"
+            
+            if truncated:
+                response += f"\n*Note: Showing first 100 files out of {total_files:,} total*\n"
+        
+        if inclusion_patterns:
+            response += f"\n**Inclusion Patterns:** {', '.join(f'`{p}`' for p in inclusion_patterns)}\n"
+        if exclusion_patterns:
+            response += f"**Exclusion Patterns:** {', '.join(f'`{p}`' for p in exclusion_patterns)}\n"
+        
+        response += "\n💡 **Next Step:** Use `index_local_filesystem` to index these files."
+        
+        return [TextContent(type="text", text=response)]
+        
+    except APIError as e:
+        logger.error(f"API error scanning local filesystem: {e}")
+        return [TextContent(
+            type="text",
+            text=f"❌ API Error: {str(e)}\n\nStatus Code: {e.status_code}\nDetails: {e.detail}"
+        )]
+    except Exception as e:
+        logger.error(f"Unexpected error scanning local filesystem: {e}")
+        return [TextContent(
+            type="text",
+            text=f"❌ Error: An unexpected error occurred while scanning: {str(e)}"
+        )]
+
+@mcp.tool()
+async def check_local_filesystem_status(source_id: str) -> List[TextContent]:
+    """
+    Check the indexing status of a local filesystem source.
+    
+    Args:
+        source_id: The source ID returned when indexing was started
+        
+    Returns:
+        Current status of the local filesystem indexing
+    """
+    try:
+        client = await ensure_api_client()
+        status = await client.check_local_filesystem_status(source_id)
+        
+        # Format status response
+        status_text = status.get("status", "unknown")
+        progress = status.get("progress", 0)
+        message = status.get("message", "")
+        error = status.get("error")
+        directory_path = status.get("directory_path", "Unknown")
+        page_count = status.get("page_count", 0)  # Number of files
+        chunk_count = status.get("chunk_count", 0)
+        
+        # Status emoji
+        status_emoji = {
+            "pending": "⏳",
+            "processing": "🔄",
+            "completed": "✅",
+            "failed": "❌",
+            "error": "❌"
+        }.get(status_text, "❓")
+        
+        response = f"{status_emoji} **Local Filesystem Status**\n\n"
+        response += f"🆔 **Source ID:** `{source_id}`\n"
+        response += f"📁 **Directory:** `{directory_path}`\n"
+        response += f"📊 **Status:** {status_text.capitalize()}\n"
+        
+        if progress > 0:
+            response += f"📈 **Progress:** {progress}%\n"
+        
+        if message:
+            response += f"💬 **Message:** {message}\n"
+        
+        if status_text == "completed":
+            response += f"\n✨ **Indexing Complete!**\n"
+            response += f"• **Files Indexed:** {page_count:,}\n"
+            response += f"• **Chunks Created:** {chunk_count:,}\n"
+            response += f"\nYou can now search this directory using `search_codebase` or the unified search!"
+        elif status_text in ["failed", "error"]:
+            response += f"\n❌ **Indexing Failed**\n"
+            if error:
+                response += f"**Error:** {error}\n"
+            response += "\nPlease check your directory path and try again."
+        elif status_text == "processing":
+            response += f"\n🔄 Indexing is in progress...\n"
+            response += "Check back in a few moments or monitor at [app.trynia.ai](https://app.trynia.ai)"
+        
+        return [TextContent(type="text", text=response)]
+        
+    except APIError as e:
+        logger.error(f"API error checking local filesystem status: {e}")
+        if e.status_code == 404:
+            return [TextContent(
+                type="text",
+                text=f"❌ Source ID `{source_id}` not found. Please check the ID and try again."
+            )]
+        return [TextContent(
+            type="text",
+            text=f"❌ API Error: {str(e)}\n\nStatus Code: {e.status_code}\nDetails: {e.detail}"
+        )]
+    except Exception as e:
+        logger.error(f"Unexpected error checking local filesystem status: {e}")
+        return [TextContent(
+            type="text",
+            text=f"❌ Error: An unexpected error occurred: {str(e)}"
+        )]
+
+@mcp.tool()
+async def search_local_filesystem(
+    source_id: str,
+    query: str,
+    include_sources: bool = True
+) -> List[TextContent]:
+    """
+    Search an indexed local filesystem directory using its source ID.
+    
+    To search local files:
+    1. First index a directory using `index_local_filesystem` - this will return a source_id
+    2. Use that source_id with this tool to search the indexed content
+    
+    Args:
+        source_id: The source ID returned when the directory was indexed (required)
+        query: Your search query in natural language (required)
+        include_sources: Whether to include source code snippets in results (default: True)
+        
+    Returns:
+        Search results with relevant file snippets and explanations
+        
+    Example:
+        # After indexing returns source_id "abc123-def456"
+        search_local_filesystem(
+            source_id="abc123-def456",
+            query="configuration settings"
+        )
+        
+    Note: To find your source IDs, use `list_documentation` and look for 
+    sources with source_type="local_filesystem"
+    """
+    try:
+        # Validate inputs
+        if not source_id:
+            return [TextContent(
+                type="text",
+                text="❌ Error: 'source_id' parameter is required. Use the ID returned from index_local_filesystem."
+            )]
+            
+        if not query:
+            return [TextContent(
+                type="text",
+                text="❌ Error: 'query' parameter is required"
+            )]
+        
+        client = await ensure_api_client()
+        
+        # Check if the source exists and is ready
+        logger.info(f"Checking status of source {source_id}")
+        try:
+            status = await client.get_data_source_status(source_id)
+            if not status:
+                return [TextContent(
+                    type="text",
+                    text=f"❌ Source ID '{source_id}' not found. Please check the ID and try again."
+                )]
+            
+            source_status = status.get("status", "unknown")
+            if source_status == "processing":
+                progress = status.get("progress", 0)
+                return [TextContent(
+                    type="text",
+                    text=f"⏳ This source is still being indexed ({progress}% complete).\n\n"
+                         f"Use `check_local_filesystem_status(\"{source_id}\")` to check progress."
+                )]
+            elif source_status == "failed":
+                error = status.get("error", "Unknown error")
+                return [TextContent(
+                    type="text",
+                    text=f"❌ This source failed to index.\n\nError: {error}"
+                )]
+            elif source_status != "completed":
+                return [TextContent(
+                    type="text",
+                    text=f"❌ Source is not ready for search. Status: {source_status}"
+                )]
+        except Exception as e:
+            logger.warning(f"Could not check source status: {e}")
+            # Continue anyway in case it's just a status check issue
+        
+        # Perform the search
+        logger.info(f"Searching local filesystem source {source_id} with query: {query}")
+        
+        # Use the unified query endpoint with data_sources parameter
+        result = client.query_unified(
+            messages=[{"role": "user", "content": query}],
+            data_sources=[source_id],
+            include_sources=include_sources,
+            stream=False
+        )
+        
+        # Parse the response
+        response_text = ""
+        async for chunk in result:
+            data = json.loads(chunk)
+            if "content" in data:
+                response_text = data["content"]
+                sources = data.get("sources", [])
+                break
+        
+        # Format the response nicely for local filesystem results
+        if response_text:
+            # Extract the local filesystem results section if present
+            if "**Local filesystem results" in response_text:
+                # Keep the original response
+                formatted_response = response_text
+            else:
+                # Create our own formatted response
+                formatted_response = f"🔍 **Search Results for Local Directory**\n"
+                formatted_response += f"🔎 Query: \"{query}\"\n\n"
+                formatted_response += response_text
+            
+            # Add sources if available and requested
+            if include_sources and sources:
+                formatted_response += "\n\n**📄 Source Details:**\n"
+                for i, source in enumerate(sources[:5], 1):
+                    metadata = source.get("metadata", {})
+                    file_path = metadata.get("file_path", "Unknown file")
+                    formatted_response += f"\n{i}. `{file_path}`\n"
+                    
+                    # Add snippet of content
+                    content = source.get("content", "")
+                    if content:
+                        # Truncate to reasonable length
+                        lines = content.split('\n')[:10]
+                        snippet = '\n'.join(lines)
+                        if len(lines) > 10:
+                            snippet += "\n..."
+                        formatted_response += f"```\n{snippet}\n```\n"
+            
+            return [TextContent(type="text", text=formatted_response)]
+        else:
+            return [TextContent(
+                type="text",
+                text=f"No results found for query: \"{query}\" in the indexed directory."
+            )]
+            
+    except APIError as e:
+        logger.error(f"API error searching local filesystem: {e}")
+        return [TextContent(
+            type="text",
+            text=f"❌ API Error: {str(e)}\n\nStatus Code: {e.status_code}\nDetails: {e.detail}"
+        )]
+    except Exception as e:
+        logger.error(f"Unexpected error searching local filesystem: {e}")
+        return [TextContent(
+            type="text",
+            text=f"❌ Error: An unexpected error occurred: {str(e)}"
+        )]
+
 @mcp.tool()
 async def visualize_codebase(
     repository: str

{nia_mcp_server-1.0.16.dist-info → nia_mcp_server-1.0.17.dist-info}/METADATA

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

{nia_mcp_server-1.0.16.dist-info → nia_mcp_server-1.0.17.dist-info}/RECORD

@@ -1,19 +1,19 @@
-nia_mcp_server/__init__.py,sha256=o1sbmg9E91Ai4_OVbf6uHc4n-0QzsJZpfCxhON3U7Zk,85
+nia_mcp_server/__init__.py,sha256=Vey2MprReAMtBucCOwDlS0ZmshGrAJ0IJ1RV6BTFT50,85
 nia_mcp_server/__main__.py,sha256=YQSpFtDeKp18r8mKr084cHnRFV4416_EKCu9FTM8_ik,394
-nia_mcp_server/api_client.py,sha256=KlzGDebSZEMC4ikrk5dtX6HWJwKU5iUU0zRqM0AyvP0,27646
+nia_mcp_server/api_client.py,sha256=L9xf7rz6i2aPKKLfYOwj8Fs0_SYqJHHZgTki0y3UtcY,30415
 nia_mcp_server/cli.py,sha256=32VSPNIocXtDgVBDZNZsxvj3kytBn54_a1pIE84vOdY,1834
 nia_mcp_server/profiles.py,sha256=2DD8PFRr5Ij4IK4sPUz0mH8aKjkrEtkKLC1R0iki2bA,7221
 nia_mcp_server/project_init.py,sha256=T0-ziJhofL4L8APwnM43BLhxtlmOHaYH-V9PF2yXLw4,7138
 nia_mcp_server/rule_transformer.py,sha256=wCxoQ1Kl_rI9mUFnh9kG5iCXYU4QInrmFQOReZfAFVo,11000
-nia_mcp_server/server.py,sha256=IgScr-xiiVuRo8UqQgCMzxjAFT8SHssktaGChCaaj5I,77855
+nia_mcp_server/server.py,sha256=hdn81qwTR_zPvOsO4wnIs7jI3HzYHvmzgKKs9QX_7-Y,94731
 nia_mcp_server/setup.py,sha256=nJXVY8NHGtWROtoH8DW-3uOgyuPs4F9dW0cNhcbCLrM,5355
 nia_mcp_server/assets/rules/claude_rules.md,sha256=HNL5GJMUbFxSpNbIAJUQWqAywjMl4lf530I1in69aNY,7380
 nia_mcp_server/assets/rules/cursor_rules.md,sha256=hd6lhzNrK1ULQUYIEVeOnyKnuLKq4hmwZPbMqGUI1Lk,1720
 nia_mcp_server/assets/rules/nia_rules.md,sha256=l6sx000uqoczoHYqOPp4hnNgyfpnhvO9NyT0fVx5nU0,8059
 nia_mcp_server/assets/rules/vscode_rules.md,sha256=fqn4aJO_bhftaCGkVoquruQHf3EaREQJQWHXq6a4FOk,6967
 nia_mcp_server/assets/rules/windsurf_rules.md,sha256=PzU2as5gaiVsV6PAzg8T_-GR7VCyRQGMjAHcSzYF_ms,3354
-nia_mcp_server-1.0.16.dist-info/METADATA,sha256=zXKq6Nlrklk02Fr_BXDB8SrS85FnsKtE1x8sVqqtrWg,1324
-nia_mcp_server-1.0.16.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-nia_mcp_server-1.0.16.dist-info/entry_points.txt,sha256=V74FQEp48pfWxPCl7B9mihtqvIJNVjCSbRfCz4ww77I,64
-nia_mcp_server-1.0.16.dist-info/licenses/LICENSE,sha256=IrdVKi3bsiB2MTLM26MltBRpwyNi-8P6Cy0EnmAN76A,1557
-nia_mcp_server-1.0.16.dist-info/RECORD,,
+nia_mcp_server-1.0.17.dist-info/METADATA,sha256=FRAGfMUlSLv3AOkry3a6Blb0LffzGze_R9nfnJq54R4,1324
+nia_mcp_server-1.0.17.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+nia_mcp_server-1.0.17.dist-info/entry_points.txt,sha256=V74FQEp48pfWxPCl7B9mihtqvIJNVjCSbRfCz4ww77I,64
+nia_mcp_server-1.0.17.dist-info/licenses/LICENSE,sha256=IrdVKi3bsiB2MTLM26MltBRpwyNi-8P6Cy0EnmAN76A,1557
+nia_mcp_server-1.0.17.dist-info/RECORD,,