nia-mcp-server 1.0.5__py3-none-any.whl → 1.0.6__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.5"
+__version__ = "1.0.6"

nia_mcp_server/api_client.py

@@ -137,7 +137,18 @@ class NIAApiClient:
         try:
             response = await self.client.get(f"{self.base_url}/v2/repositories")
             response.raise_for_status()
-            return response.json()
+            data = response.json()
+            
+            # Ensure we always return a list
+            if not isinstance(data, list):
+                logger.error(f"Unexpected response type from list_repositories: {type(data)}, data: {data}")
+                # If it's a dict with an error message, raise it
+                if isinstance(data, dict) and "error" in data:
+                    raise APIError(f"API returned error: {data['error']}")
+                # Otherwise return empty list
+                return []
+            
+            return data
         except httpx.HTTPStatusError as e:
             logger.error(f"Caught HTTPStatusError in list_repositories: status={e.response.status_code}, detail={e.response.text}")
             raise self._handle_api_error(e)
@@ -336,6 +347,53 @@ class NIAApiClient:
             logger.error(f"Failed to delete repository: {e}")
             return False
     
+    async def rename_repository(self, owner_repo: str, new_name: str) -> Dict[str, Any]:
+        """Rename a repository's display name."""
+        try:
+            # Check if this looks like owner/repo format (contains /)
+            if '/' in owner_repo:
+                # First, get the repository ID
+                status = await self.get_repository_status(owner_repo)
+                if not status:
+                    raise APIError(f"Repository {owner_repo} not found", 404)
+                
+                # Extract the repository ID from status
+                repo_id = status.get("repository_id") or status.get("id")
+                if not repo_id:
+                    # Try to get it from list as fallback
+                    repos = await self.list_repositories()
+                    for repo in repos:
+                        if repo.get("repository") == owner_repo:
+                            repo_id = repo.get("repository_id") or repo.get("id")
+                            break
+                
+                if not repo_id:
+                    raise APIError(f"No repository ID found for {owner_repo}", 404)
+                    
+                # Rename using the ID
+                response = await self.client.patch(
+                    f"{self.base_url}/v2/repositories/{repo_id}/rename",
+                    json={"new_name": new_name}
+                )
+                response.raise_for_status()
+                return response.json()
+            else:
+                # Assume it's already a repository ID
+                response = await self.client.patch(
+                    f"{self.base_url}/v2/repositories/{owner_repo}/rename",
+                    json={"new_name": new_name}
+                )
+                response.raise_for_status()
+                return response.json()
+                
+        except httpx.HTTPStatusError as e:
+            raise self._handle_api_error(e)
+        except APIError:
+            raise
+        except Exception as e:
+            logger.error(f"Failed to rename repository: {e}")
+            raise APIError(f"Failed to rename repository: {str(e)}")
+    
     # Data Source methods
     
     async def create_data_source(
@@ -408,6 +466,22 @@ class NIAApiClient:
             logger.error(f"Failed to delete data source: {e}")
             return False
     
+    async def rename_data_source(self, source_id: str, new_name: str) -> Dict[str, Any]:
+        """Rename a data source's display name."""
+        try:
+            response = await self.client.patch(
+                f"{self.base_url}/v2/data-sources/{source_id}/rename",
+                json={"new_name": new_name}
+            )
+            response.raise_for_status()
+            return response.json()
+            
+        except httpx.HTTPStatusError as e:
+            raise self._handle_api_error(e)
+        except Exception as e:
+            logger.error(f"Failed to rename data source: {e}")
+            raise APIError(f"Failed to rename data source: {str(e)}")
+    
     async def query_unified(
         self,
         messages: List[Dict[str, str]],

nia_mcp_server/profiles.py

@@ -0,0 +1,263 @@
+"""
+Nia Profile Configurations
+Defines IDE/Editor profile configurations for rule transformation
+"""
+from typing import Dict, Any, Optional, List
+
+# Profile configurations define how rules are transformed and where they're placed
+PROFILE_CONFIGS: Dict[str, Dict[str, Any]] = {
+    "cursor": {
+        "name": "Cursor",
+        "target_dir": ".cursor/rules",
+        "file_extension": ".mdc",
+        "file_map": {
+            "cursor_rules.md": "nia.mdc"
+        },
+        "mcp_config": True,
+        "format": "mdc",
+        "features": ["mcp", "composer", "inline_edits"],
+        "global_replacements": {
+            "# Nia": "# Nia for Cursor",
+            "{{IDE}}": "Cursor"
+        }
+    },
+    
+    "vscode": {
+        "name": "Visual Studio Code",
+        "target_dir": ".vscode",
+        "file_extension": ".md",
+        "file_map": {
+            "nia_rules.md": "nia-guide.md",
+            "vscode_rules.md": "nia-vscode-integration.md"
+        },
+        "mcp_config": False,
+        "format": "markdown",
+        "features": ["tasks", "snippets", "terminal_integration"],
+        "global_replacements": {
+            "# Nia": "# Nia for VSCode",
+            "{{IDE}}": "VSCode"
+        },
+        "additional_files": {
+            "tasks.json": "vscode_tasks_template",
+            "nia.code-snippets": "vscode_snippets_template"
+        }
+    },
+    
+    "claude": {
+        "name": "Claude Desktop",
+        "target_dir": ".claude",
+        "file_extension": ".md",
+        "file_map": {
+            "nia_rules.md": "nia_rules.md",
+            "claude_rules.md": "nia_claude_integration.md"
+        },
+        "mcp_config": False,
+        "format": "markdown",
+        "features": ["conversational", "context_aware", "multi_step"],
+        "global_replacements": {
+            "# Nia": "# Nia for Claude Desktop",
+            "{{IDE}}": "Claude"
+        }
+    },
+    
+    "windsurf": {
+        "name": "Windsurf",
+        "target_dir": ".windsurfrules",
+        "file_extension": ".md",
+        "file_map": {
+            "nia_rules.md": "nia_rules.md",
+            "windsurf_rules.md": "windsurf_nia_guide.md"
+        },
+        "mcp_config": True,
+        "format": "markdown",
+        "features": ["cascade", "memories", "flows"],
+        "global_replacements": {
+            "# Nia": "# Nia for Windsurf Cascade",
+            "{{IDE}}": "Windsurf"
+        }
+    },
+    
+    "cline": {
+        "name": "Cline",
+        "target_dir": ".cline",
+        "file_extension": ".md",
+        "file_map": {
+            "nia_rules.md": "nia_rules.md"
+        },
+        "mcp_config": True,
+        "format": "markdown",
+        "features": ["autonomous", "task_planning"],
+        "global_replacements": {
+            "# Nia": "# Nia for Cline",
+            "{{IDE}}": "Cline"
+        }
+    },
+    
+    "codex": {
+        "name": "OpenAI Codex",
+        "target_dir": ".codex",
+        "file_extension": ".md",
+        "file_map": {
+            "nia_rules.md": "nia_codex_guide.md"
+        },
+        "mcp_config": False,
+        "format": "markdown",
+        "features": ["completion", "generation"],
+        "global_replacements": {
+            "# Nia": "# Nia for Codex",
+            "{{IDE}}": "Codex"
+        }
+    },
+    
+    "zed": {
+        "name": "Zed",
+        "target_dir": ".zed",
+        "file_extension": ".md",
+        "file_map": {
+            "nia_rules.md": "nia_assistant.md"
+        },
+        "mcp_config": False,
+        "format": "markdown",
+        "features": ["assistant", "collaboration"],
+        "global_replacements": {
+            "# Nia": "# Nia for Zed",
+            "{{IDE}}": "Zed"
+        }
+    },
+    
+    "jetbrains": {
+        "name": "JetBrains IDEs",
+        "target_dir": ".idea/nia",
+        "file_extension": ".md",
+        "file_map": {
+            "nia_rules.md": "nia_guide.md"
+        },
+        "mcp_config": False,
+        "format": "markdown",
+        "features": ["ai_assistant", "code_completion"],
+        "global_replacements": {
+            "# Nia": "# Nia for JetBrains",
+            "{{IDE}}": "JetBrains IDE"
+        }
+    },
+    
+    "neovim": {
+        "name": "Neovim",
+        "target_dir": ".config/nvim/nia",
+        "file_extension": ".md",
+        "file_map": {
+            "nia_rules.md": "nia_guide.md"
+        },
+        "mcp_config": False,
+        "format": "markdown",
+        "features": ["copilot", "cmp"],
+        "global_replacements": {
+            "# Nia": "# Nia for Neovim",
+            "{{IDE}}": "Neovim"
+        }
+    },
+    
+    "sublime": {
+        "name": "Sublime Text",
+        "target_dir": ".sublime",
+        "file_extension": ".md",
+        "file_map": {
+            "nia_rules.md": "nia_guide.md"
+        },
+        "mcp_config": False,
+        "format": "markdown",
+        "features": ["copilot"],
+        "global_replacements": {
+            "# Nia": "# Nia for Sublime Text",
+            "{{IDE}}": "Sublime Text"
+        }
+    }
+}
+
+# Additional template configurations for specific file types
+TEMPLATE_CONFIGS = {
+    "vscode_tasks_template": {
+        "content": """{
+  "version": "2.0.0",
+  "tasks": [
+    {
+      "label": "Nia: Index Repository",
+      "type": "shell",
+      "command": "echo 'Run: index_repository ${input:repoUrl}'",
+      "problemMatcher": []
+    },
+    {
+      "label": "Nia: Search Codebase",
+      "type": "shell",
+      "command": "echo 'Run: search_codebase \\"${input:searchQuery}\\"'",
+      "problemMatcher": []
+    },
+    {
+      "label": "Nia: List Repositories",
+      "type": "shell",
+      "command": "echo 'Run: list_repositories'",
+      "problemMatcher": []
+    }
+  ],
+  "inputs": [
+    {
+      "id": "repoUrl",
+      "type": "promptString",
+      "description": "GitHub repository URL"
+    },
+    {
+      "id": "searchQuery",
+      "type": "promptString",
+      "description": "Search query"
+    }
+  ]
+}"""
+    },
+    
+    "vscode_snippets_template": {
+        "content": """{
+  "Nia Index": {
+    "prefix": "nia-index",
+    "body": ["index_repository ${1:repo_url}"],
+    "description": "Index a repository with Nia"
+  },
+  "Nia Search": {
+    "prefix": "nia-search",
+    "body": ["search_codebase \\"${1:query}\\""],
+    "description": "Search indexed repositories"
+  },
+  "Nia Web Search": {
+    "prefix": "nia-web",
+    "body": ["nia_web_search \\"${1:query}\\""],
+    "description": "Search the web with Nia"
+  },
+  "Nia Research": {
+    "prefix": "nia-research",
+    "body": ["nia_deep_research_agent \\"${1:query}\\""],
+    "description": "Perform deep research with Nia"
+  }
+}"""
+    }
+}
+
+
+def get_profile_config(profile: str) -> Optional[Dict[str, Any]]:
+    """Get configuration for a specific profile"""
+    return PROFILE_CONFIGS.get(profile)
+
+
+def get_supported_profiles() -> List[str]:
+    """Get list of all supported profiles"""
+    return list(PROFILE_CONFIGS.keys())
+
+
+def get_profile_features(profile: str) -> List[str]:
+    """Get features supported by a profile"""
+    config = get_profile_config(profile)
+    return config.get("features", []) if config else []
+
+
+def is_mcp_enabled(profile: str) -> bool:
+    """Check if a profile supports MCP"""
+    config = get_profile_config(profile)
+    return config.get("mcp_config", False) if config else False

nia_mcp_server/project_init.py

@@ -0,0 +1,193 @@
+"""
+Nia Project Initialization Module
+Handles creation of Nia-enabled project structures and configurations
+"""
+import os
+import json
+import shutil
+import logging
+import subprocess
+from pathlib import Path
+from datetime import datetime
+from typing import List, Dict, Optional, Any
+from .profiles import PROFILE_CONFIGS, get_profile_config
+from .rule_transformer import transform_rules_for_profile
+
+logger = logging.getLogger(__name__)
+
+class NIAProjectInitializer:
+    """Handles Nia project initialization with support for multiple IDE profiles"""
+    
+    def __init__(self, project_root: str):
+        self.project_root = Path(project_root).resolve()
+        self.assets_dir = Path(__file__).parent.parent.parent / "assets"
+        self.templates_dir = self.assets_dir / "templates"
+        self.rules_dir = self.assets_dir / "rules"
+        
+        # Validate that required directories exist
+        if not self.assets_dir.exists():
+            raise RuntimeError(f"Assets directory not found at {self.assets_dir}. Nia MCP server may not be installed correctly.")
+        if not self.rules_dir.exists():
+            raise RuntimeError(f"Rules directory not found at {self.rules_dir}. Nia MCP server may not be installed correctly.")
+        
+    def initialize_project(
+        self,
+        profiles: List[str] = ["cursor"]
+    ) -> Dict[str, Any]:
+        """
+        Initialize a Nia project with specified profiles
+        
+        Args:
+            profiles: List of IDE profiles to set up (cursor, vscode, claude, etc.)
+            
+        Returns:
+            Dictionary with initialization results and status
+        """
+        try:
+            results = {
+                "success": True,
+                "project_root": str(self.project_root),
+                "profiles_initialized": [],
+                "files_created": [],
+                "warnings": [],
+                "next_steps": []
+            }
+            
+            # Validate project root
+            if not self.project_root.exists():
+                os.makedirs(self.project_root, exist_ok=True)
+                
+            # No longer creating .nia directory or config files
+            
+            # Process each profile
+            for profile in profiles:
+                if profile not in PROFILE_CONFIGS:
+                    results["warnings"].append(f"Unknown profile: {profile}")
+                    continue
+                    
+                profile_results = self._initialize_profile(profile)
+                if profile_results["success"]:
+                    results["profiles_initialized"].append(profile)
+                    results["files_created"].extend(profile_results["files_created"])
+                else:
+                    results["warnings"].append(f"Failed to initialize {profile}: {profile_results.get('error')}")
+            
+            # Generate next steps
+            results["next_steps"].extend(self._generate_next_steps(profiles))
+            
+            logger.info(f"Successfully initialized Nia project at {self.project_root}")
+            return results
+            
+        except Exception as e:
+            logger.error(f"Failed to initialize project: {e}")
+            return {
+                "success": False,
+                "error": str(e),
+                "project_root": str(self.project_root)
+            }
+    
+    def _create_nia_directories(self):
+        """Create the .nia directory structure"""
+        # Simplified - no unnecessary directories or files
+        pass
+    
+    
+    
+    
+    def _initialize_profile(self, profile: str) -> Dict[str, Any]:
+        """Initialize a specific IDE profile"""
+        try:
+            profile_config = get_profile_config(profile)
+            if not profile_config:
+                return {"success": False, "error": "Profile configuration not found"}
+            
+            files_created = []
+            
+            # Create profile directory
+            profile_dir = self.project_root / profile_config["target_dir"]
+            os.makedirs(profile_dir, exist_ok=True)
+            
+            # Transform and copy rules
+            rule_files = transform_rules_for_profile(
+                profile,
+                self.rules_dir,
+                profile_dir,
+                self.project_root
+            )
+            
+            for rule_file in rule_files:
+                files_created.append(str(Path(rule_file).relative_to(self.project_root)))
+            
+            # Handle profile-specific setup
+            if profile == "vscode" and profile_config.get("additional_files"):
+                # VSCode gets tasks.json and snippets from additional_files
+                pass  # Handled by transform_rules_for_profile
+            # No need to setup MCP config - user is already running through MCP!
+            
+            return {
+                "success": True,
+                "files_created": files_created
+            }
+            
+        except Exception as e:
+            logger.error(f"Failed to initialize profile {profile}: {e}")
+            return {"success": False, "error": str(e)}
+    
+    
+    
+    def _generate_next_steps(self, profiles: List[str]) -> List[str]:
+        """Generate helpful next steps for the user"""
+        steps = []
+        
+        # Check for current git repository
+        if (self.project_root / ".git").exists():
+            try:
+                # Use subprocess for safer command execution
+                result = subprocess.run(
+                    ["git", "remote", "get-url", "origin"],
+                    cwd=self.project_root,
+                    capture_output=True,
+                    text=True,
+                    check=False  # Don't raise exception if git command fails
+                )
+                git_remote = result.stdout.strip()
+                if git_remote and "github.com" in git_remote:
+                    steps.append(f"Index this repository: index_repository {git_remote}")
+            except (subprocess.SubprocessError, FileNotFoundError):
+                # Git might not be installed or available
+                logger.debug("Could not get git remote URL")
+        
+        # Profile-specific steps
+        if "cursor" in profiles:
+            steps.append("Restart Cursor to load Nia MCP server")
+        if "vscode" in profiles:
+            steps.append("Reload VSCode window to apply settings")
+        
+        # General steps
+        steps.extend([
+            "Explore available commands with list_repositories",
+            "Search for code patterns with search_codebase",
+            "Find new libraries with nia_web_search"
+        ])
+        
+        return steps
+
+
+def initialize_nia_project(
+    project_root: str,
+    profiles: List[str] = ["cursor"]
+) -> Dict[str, Any]:
+    """
+    Convenience function to initialize a Nia project
+    
+    Args:
+        project_root: Root directory of the project
+        profiles: List of IDE profiles to set up
+        
+    Returns:
+        Dictionary with initialization results
+    """
+    initializer = NIAProjectInitializer(project_root)
+    return initializer.initialize_project(
+        profiles=profiles
+    )

nia_mcp_server/rule_transformer.py

@@ -0,0 +1,363 @@
+"""
+Nia Rule Transformer
+Handles transformation of rule files for different IDE profiles
+"""
+import os
+import re
+import logging
+from pathlib import Path
+from typing import List, Dict, Any, Optional
+from .profiles import get_profile_config, TEMPLATE_CONFIGS
+
+logger = logging.getLogger(__name__)
+
+
+def transform_rules_for_profile(
+    profile: str,
+    source_dir: Path,
+    target_dir: Path,
+    project_root: Path
+) -> List[str]:
+    """
+    Transform rule files for a specific profile
+    
+    Args:
+        profile: Profile name (cursor, vscode, etc.)
+        source_dir: Directory containing source rule files
+        target_dir: Directory to write transformed rules
+        project_root: Project root directory for context
+        
+    Returns:
+        List of created file paths
+    """
+    profile_config = get_profile_config(profile)
+    if not profile_config:
+        raise ValueError(f"Unknown profile: {profile}")
+    
+    created_files = []
+    file_map = profile_config.get("file_map", {})
+    
+    # Process each file in the file map
+    for source_file, target_file in file_map.items():
+        source_path = source_dir / source_file
+        
+        if not source_path.exists():
+            logger.warning(f"Source file not found: {source_path}")
+            continue
+        
+        # Read source content
+        content = source_path.read_text()
+        
+        # Apply transformations
+        transformed_content = apply_transformations(
+            content,
+            profile_config,
+            project_root
+        )
+        
+        # Write to target
+        target_path = target_dir / target_file
+        os.makedirs(target_path.parent, exist_ok=True)
+        target_path.write_text(transformed_content)
+        created_files.append(str(target_path))
+        
+        logger.info(f"Created rule file: {target_path}")
+    
+    # Handle additional files (like VSCode tasks.json)
+    additional_files = profile_config.get("additional_files", {})
+    for filename, template_key in additional_files.items():
+        if template_key in TEMPLATE_CONFIGS:
+            template_config = TEMPLATE_CONFIGS[template_key]
+            target_path = target_dir / filename
+            
+            # Apply any necessary transformations to template
+            content = template_config["content"]
+            content = apply_template_variables(content, project_root)
+            
+            target_path.write_text(content)
+            created_files.append(str(target_path))
+            logger.info(f"Created additional file: {target_path}")
+    
+    return created_files
+
+
+def apply_transformations(
+    content: str,
+    profile_config: Dict[str, Any],
+    project_root: Path
+) -> str:
+    """
+    Apply profile-specific transformations to content
+    
+    Args:
+        content: Original content
+        profile_config: Profile configuration
+        project_root: Project root for context
+        
+    Returns:
+        Transformed content
+    """
+    # Apply global replacements
+    global_replacements = profile_config.get("global_replacements", {})
+    for pattern, replacement in global_replacements.items():
+        content = content.replace(pattern, replacement)
+    
+    # Apply project-specific variables
+    content = apply_template_variables(content, project_root)
+    
+    # Apply format-specific transformations
+    if profile_config.get("format") == "markdown":
+        content = transform_markdown_format(content, profile_config)
+    elif profile_config.get("format") == "mdc":
+        content = transform_to_mdc_format(content, profile_config)
+    
+    # Apply feature-specific enhancements
+    features = profile_config.get("features", [])
+    content = enhance_for_features(content, features, profile_config)
+    
+    return content
+
+
+def apply_template_variables(content: str, project_root: Path) -> str:
+    """
+    Replace template variables with actual values
+    
+    Args:
+        content: Content with template variables
+        project_root: Project root directory
+        
+    Returns:
+        Content with variables replaced
+    """
+    variables = {
+        "{{PROJECT_ROOT}}": str(project_root),
+        "{{PROJECT_NAME}}": project_root.name,
+        "{{WORKSPACE_FOLDER}}": "${workspaceFolder}",
+        "{{USER_HOME}}": str(Path.home()),
+    }
+    
+    for var, value in variables.items():
+        content = content.replace(var, value)
+    
+    return content
+
+
+def transform_markdown_format(content: str, profile_config: Dict[str, Any]) -> str:
+    """
+    Apply markdown-specific transformations
+    
+    Args:
+        content: Markdown content
+        profile_config: Profile configuration
+        
+    Returns:
+        Transformed markdown
+    """
+    # Add profile-specific header if not present
+    profile_name = profile_config.get("name", "Unknown")
+    if not content.startswith(f"# Nia Integration for {profile_name}"):
+        # Check if it starts with a generic Nia header
+        if content.startswith("# Nia"):
+            # Replace the first line
+            lines = content.split('\n')
+            lines[0] = f"# Nia Integration for {profile_name}"
+            content = '\n'.join(lines)
+    
+    # Enhance code blocks with profile-specific annotations
+    if "mcp" in profile_config.get("features", []):
+        content = enhance_mcp_code_blocks(content)
+    
+    return content
+
+
+def transform_to_mdc_format(content: str, profile_config: Dict[str, Any]) -> str:
+    """
+    Transform markdown content to MDC format for Cursor
+    
+    Args:
+        content: Original markdown content
+        profile_config: Profile configuration
+        
+    Returns:
+        MDC formatted content
+    """
+    # Extract the first line as description
+    lines = content.split('\n')
+    description = ""
+    content_start = 0
+    
+    if lines and lines[0].startswith('#'):
+        # Use the first header as description
+        description = lines[0].replace('#', '').strip()
+        content_start = 1
+    else:
+        description = "Nia Knowledge Agent Integration Rules"
+    
+    # Build MDC header
+    # For Nia rules, we want them always applied since they guide AI assistant behavior
+    mdc_header = f"""---
+description: {description}
+alwaysApply: true
+---
+"""
+    
+    # Get the rest of the content
+    remaining_content = '\n'.join(lines[content_start:]).strip()
+    
+    # Apply markdown transformations first
+    remaining_content = transform_markdown_format(remaining_content, profile_config)
+    
+    return mdc_header + '\n' + remaining_content
+
+
+def enhance_for_features(
+    content: str,
+    features: List[str],
+    profile_config: Dict[str, Any]
+) -> str:
+    """
+    Enhance content based on profile features
+    
+    Args:
+        content: Original content
+        features: List of features supported by profile
+        profile_config: Profile configuration
+        
+    Returns:
+        Enhanced content
+    """
+    # Add feature-specific sections if not present
+    enhancements = []
+    
+    if "mcp" in features and "## MCP Integration" not in content:
+        enhancements.append(generate_mcp_section(profile_config))
+    
+    if "composer" in features and "## Composer Usage" not in content:
+        enhancements.append(generate_composer_section())
+    
+    if "tasks" in features and "## Task Automation" not in content:
+        enhancements.append(generate_tasks_section())
+    
+    if "terminal_integration" in features and "## Terminal Commands" not in content:
+        enhancements.append(generate_terminal_section())
+    
+    # Append enhancements to content
+    if enhancements:
+        content += "\n\n" + "\n\n".join(enhancements)
+    
+    return content
+
+
+def enhance_mcp_code_blocks(content: str) -> str:
+    """
+    Enhance code blocks for MCP-enabled profiles
+    
+    Args:
+        content: Markdown content
+        
+    Returns:
+        Enhanced content
+    """
+    # Pattern to find code blocks with Nia commands
+    pattern = r'```(\w*)\n(.*?nia.*?)\n```'
+    
+    def replacer(match):
+        lang = match.group(1) or "bash"
+        code = match.group(2)
+        
+        # If it's a NIA command, add annotation
+        if any(cmd in code for cmd in ["index_repository", "search_codebase", "list_repositories"]):
+            return f'```{lang}\n# MCP Command - Run this in your AI assistant\n{code}\n```'
+        return match.group(0)
+    
+    return re.sub(pattern, replacer, content, flags=re.DOTALL)
+
+
+def generate_mcp_section(profile_config: Dict[str, Any]) -> str:
+    """Generate MCP integration section"""
+    profile_name = profile_config.get("name", "IDE")
+    return f"""## MCP Integration
+
+{profile_name} supports Nia through the Model Context Protocol (MCP). After initialization:
+
+1. **Restart {profile_name}** to load the Nia MCP server
+2. **Verify connection** by running: `list_repositories`
+3. **Set API key** in your environment or {profile_name} settings
+
+The MCP server provides direct access to all Nia commands within your AI assistant."""
+
+
+def generate_composer_section() -> str:
+    """Generate Composer-specific section"""
+    return """## Composer Usage
+
+When using Cursor's Composer:
+
+1. **Start with context**: Always check indexed repositories first
+2. **Natural language**: Use complete questions, not keywords
+3. **Inline results**: Nia results appear directly in your code
+4. **Multi-file**: Reference multiple files from search results
+
+Example:
+```
+Composer: "How does authentication work in this Next.js app?"
+[Nia searches indexed codebase and shows relevant files]
+```"""
+
+
+def generate_tasks_section() -> str:
+    """Generate tasks automation section"""
+    return """## Task Automation
+
+Quick tasks are configured in `.vscode/tasks.json`:
+
+- **Ctrl+Shift+P** → "Tasks: Run Task"
+- Select "Nia: Index Repository" or other Nia tasks
+- Follow prompts for input
+
+Custom keyboard shortcuts can be added in keybindings.json."""
+
+
+def generate_terminal_section() -> str:
+    """Generate terminal integration section"""
+    return """## Terminal Commands
+
+Quick aliases for your terminal:
+
+```bash
+# Add to your shell profile (.bashrc, .zshrc, etc.)
+alias nia-index='echo "index_repository"'
+alias nia-search='echo "search_codebase"'
+alias nia-list='echo "list_repositories"'
+```
+
+Use these in the integrated terminal for quick access."""
+
+
+def create_profile_specific_file(
+    profile: str,
+    filename: str,
+    content: str,
+    target_dir: Path
+) -> Optional[str]:
+    """
+    Create a profile-specific file
+    
+    Args:
+        profile: Profile name
+        filename: Target filename
+        content: File content
+        target_dir: Target directory
+        
+    Returns:
+        Created file path or None
+    """
+    try:
+        file_path = target_dir / filename
+        os.makedirs(file_path.parent, exist_ok=True)
+        file_path.write_text(content)
+        logger.info(f"Created {profile} file: {file_path}")
+        return str(file_path)
+    except Exception as e:
+        logger.error(f"Failed to create {filename} for {profile}: {e}")
+        return None

nia_mcp_server/server.py

@@ -1,5 +1,5 @@
 """
-NIA MCP Proxy Server - Lightweight server that communicates with NIA API
+Nia MCP Proxy Server - Lightweight server that communicates with Nia API
 """
 import os
 import logging
@@ -12,6 +12,8 @@ from urllib.parse import urlparse
 from mcp.server.fastmcp import FastMCP
 from mcp.types import TextContent, Resource
 from .api_client import NIAApiClient, APIError
+from .project_init import initialize_nia_project
+from .profiles import get_supported_profiles
 from dotenv import load_dotenv
 import json
 
@@ -167,7 +169,26 @@ async def search_codebase(
         # Get all indexed repositories if not specified
         if not repositories:
             all_repos = await client.list_repositories()
-            repositories = [repo["repository"] for repo in all_repos if repo.get("status") == "completed"]
+            
+            # Ensure all_repos is a list and contains dictionaries
+            if not isinstance(all_repos, list):
+                logger.error(f"Unexpected type for all_repos: {type(all_repos)}")
+                return [TextContent(
+                    type="text",
+                    text="❌ Error retrieving repositories. The API returned an unexpected response."
+                )]
+            
+            repositories = []
+            for repo in all_repos:
+                if isinstance(repo, dict) and repo.get("status") == "completed":
+                    repo_name = repo.get("repository")
+                    if repo_name:
+                        repositories.append(repo_name)
+                    else:
+                        logger.warning(f"Repository missing 'repository' field: {repo}")
+                else:
+                    logger.warning(f"Unexpected repository format: {type(repo)}, value: {repo}")
+            
             if not repositories:
                 return [TextContent(
                     type="text",
@@ -364,7 +385,17 @@ async def list_repositories() -> List[TextContent]:
         
         for repo in repositories:
             status_icon = "✅" if repo.get("status") == "completed" else "⏳"
-            lines.append(f"\n## {status_icon} {repo['repository']}")
+            
+            # Show display name if available, otherwise show repository
+            display_name = repo.get("display_name")
+            repo_name = repo['repository']
+            
+            if display_name:
+                lines.append(f"\n## {status_icon} {display_name}")
+                lines.append(f"- **Repository:** {repo_name}")
+            else:
+                lines.append(f"\n## {status_icon} {repo_name}")
+            
             lines.append(f"- **Branch:** {repo.get('branch', 'main')}")
             lines.append(f"- **Status:** {repo.get('status', 'unknown')}")
             if repo.get("indexed_at"):
@@ -559,7 +590,17 @@ async def list_documentation() -> List[TextContent]:
         
         for source in sources:
             status_icon = "✅" if source.get("status") == "completed" else "⏳"
-            lines.append(f"\n## {status_icon} {source.get('url', 'Unknown URL')}")
+            
+            # Show display name if available, otherwise show URL
+            display_name = source.get("display_name")
+            url = source.get('url', 'Unknown URL')
+            
+            if display_name:
+                lines.append(f"\n## {status_icon} {display_name}")
+                lines.append(f"- **URL:** {url}")
+            else:
+                lines.append(f"\n## {status_icon} {url}")
+            
             lines.append(f"- **ID:** {source['id']}")
             lines.append(f"- **Status:** {source.get('status', 'unknown')}")
             lines.append(f"- **Type:** {source.get('source_type', 'web')}")
@@ -727,6 +768,100 @@ async def delete_repository(repository: str) -> List[TextContent]:
             text=f"❌ Error deleting repository: {str(e)}"
         )]
 
+@mcp.tool()
+async def rename_repository(repository: str, new_name: str) -> List[TextContent]:
+    """
+    Rename an indexed repository for better organization.
+    
+    Args:
+        repository: Repository in owner/repo format
+        new_name: New display name for the repository (1-100 characters)
+        
+    Returns:
+        Confirmation of rename operation
+    """
+    try:
+        # Validate name length
+        if not new_name or len(new_name) > 100:
+            return [TextContent(
+                type="text",
+                text="❌ Display name must be between 1 and 100 characters."
+            )]
+        
+        client = await ensure_api_client()
+        result = await client.rename_repository(repository, new_name)
+        
+        if result.get("success"):
+            return [TextContent(
+                type="text",
+                text=f"✅ Successfully renamed repository '{repository}' to '{new_name}'"
+            )]
+        else:
+            return [TextContent(
+                type="text",
+                text=f"❌ Failed to rename repository: {result.get('message', 'Unknown error')}"
+            )]
+            
+    except APIError as e:
+        logger.error(f"API Error renaming repository: {e}")
+        error_msg = f"❌ {str(e)}"
+        if e.status_code == 403 and "lifetime limit" in str(e).lower():
+            error_msg += "\n\n💡 Tip: You've reached the free tier limit. Upgrade to Pro for unlimited access."
+        return [TextContent(type="text", text=error_msg)]
+    except Exception as e:
+        logger.error(f"Error renaming repository: {e}")
+        return [TextContent(
+            type="text",
+            text=f"❌ Error renaming repository: {str(e)}"
+        )]
+
+@mcp.tool()
+async def rename_documentation(source_id: str, new_name: str) -> List[TextContent]:
+    """
+    Rename a documentation source for better organization.
+    
+    Args:
+        source_id: Documentation source ID
+        new_name: New display name for the documentation (1-100 characters)
+        
+    Returns:
+        Confirmation of rename operation
+    """
+    try:
+        # Validate name length
+        if not new_name or len(new_name) > 100:
+            return [TextContent(
+                type="text",
+                text="❌ Display name must be between 1 and 100 characters."
+            )]
+        
+        client = await ensure_api_client()
+        result = await client.rename_data_source(source_id, new_name)
+        
+        if result.get("success"):
+            return [TextContent(
+                type="text",
+                text=f"✅ Successfully renamed documentation source to '{new_name}'"
+            )]
+        else:
+            return [TextContent(
+                type="text",
+                text=f"❌ Failed to rename documentation: {result.get('message', 'Unknown error')}"
+            )]
+            
+    except APIError as e:
+        logger.error(f"API Error renaming documentation: {e}")
+        error_msg = f"❌ {str(e)}"
+        if e.status_code == 403 and "lifetime limit" in str(e).lower():
+            error_msg += "\n\n💡 Tip: You've reached the free tier limit. Upgrade to Pro for unlimited access."
+        return [TextContent(type="text", text=error_msg)]
+    except Exception as e:
+        logger.error(f"Error renaming documentation: {e}")
+        return [TextContent(
+            type="text",
+            text=f"❌ Error renaming documentation: {str(e)}"
+        )]
+
 @mcp.tool()
 async def nia_web_search(
     query: str,
@@ -781,7 +916,7 @@ async def nia_web_search(
         other_content = result.get("other_content", [])
         
         # Format response to naturally guide next actions
-        response_text = f"## 🔍 NIA Web Search Results for: \"{query}\"\n\n"
+        response_text = f"## 🔍 Nia Web Search Results for: \"{query}\"\n\n"
         
         if days_back:
             response_text += f"*Showing results from the last {days_back} days*\n\n"
@@ -806,7 +941,7 @@ async def nia_web_search(
             
             # Be more aggressive based on query specificity
             if len(github_repos) == 1 or any(specific_word in query.lower() for specific_word in ["specific", "exact", "particular", "find me", "looking for"]):
-                response_text += "**🚀 RECOMMENDED ACTION - Index this repository with NIA:**\n"
+                response_text += "**🚀 RECOMMENDED ACTION - Index this repository with Nia:**\n"
                 response_text += f"```\nIndex {github_repos[0]['owner_repo']}\n```\n"
                 response_text += "✨ This will enable AI-powered code search, understanding, and analysis!\n\n"
             else:
@@ -1075,6 +1210,162 @@ async def nia_deep_research_agent(
                  "Try simplifying your question or using the regular nia_web_search tool."
         )]
 
+@mcp.tool()
+async def initialize_project(
+    project_root: str,
+    profiles: Optional[List[str]] = None
+) -> List[TextContent]:
+    """
+    Initialize a NIA-enabled project with IDE-specific rules and configurations.
+    
+    This tool sets up your project with NIA integration, creating configuration files
+    and rules tailored to your IDE or editor. It enables AI assistants to better
+    understand and work with NIA's knowledge search capabilities.
+    
+    Args:
+        project_root: Absolute path to the project root directory
+        profiles: List of IDE profiles to set up (default: ["cursor"]). 
+                 Options: cursor, vscode, claude, windsurf, cline, codex, zed, jetbrains, neovim, sublime
+        
+    Returns:
+        Status of the initialization with created files and next steps
+    
+    Examples:
+        - Basic: initialize_project("/path/to/project")
+        - Multiple IDEs: initialize_project("/path/to/project", profiles=["cursor", "vscode"])
+        - Specific IDE: initialize_project("/path/to/project", profiles=["windsurf"])
+    """
+    try:
+        # Validate project root
+        project_path = Path(project_root)
+        if not project_path.is_absolute():
+            return [TextContent(
+                type="text",
+                text=f"❌ Error: project_root must be an absolute path. Got: {project_root}"
+            )]
+        
+        # Default to cursor profile if none specified
+        if profiles is None:
+            profiles = ["cursor"]
+        
+        # Validate profiles
+        supported = get_supported_profiles()
+        invalid_profiles = [p for p in profiles if p not in supported]
+        if invalid_profiles:
+            return [TextContent(
+                type="text",
+                text=f"❌ Unknown profiles: {', '.join(invalid_profiles)}\n\n"
+                     f"Supported profiles: {', '.join(supported)}"
+            )]
+        
+        logger.info(f"Initializing NIA project at {project_root} with profiles: {profiles}")
+        
+        # Initialize the project
+        result = initialize_nia_project(
+            project_root=project_root,
+            profiles=profiles
+        )
+        
+        if not result.get("success"):
+            return [TextContent(
+                type="text",
+                text=f"❌ Failed to initialize project: {result.get('error', 'Unknown error')}"
+            )]
+        
+        # Format success response
+        response_lines = [
+            f"✅ Successfully initialized NIA project at: {project_root}",
+            "",
+            "## 📁 Created Files:",
+        ]
+        
+        for file in result.get("files_created", []):
+            response_lines.append(f"- {file}")
+        
+        if result.get("profiles_initialized"):
+            response_lines.extend([
+                "",
+                "## 🎨 Initialized Profiles:",
+            ])
+            for profile in result["profiles_initialized"]:
+                response_lines.append(f"- {profile}")
+        
+        if result.get("warnings"):
+            response_lines.extend([
+                "",
+                "## ⚠️ Warnings:",
+            ])
+            for warning in result["warnings"]:
+                response_lines.append(f"- {warning}")
+        
+        if result.get("next_steps"):
+            response_lines.extend([
+                "",
+                "## 🚀 Next Steps:",
+            ])
+            for i, step in enumerate(result["next_steps"], 1):
+                response_lines.append(f"{i}. {step}")
+        
+        # Add profile-specific instructions
+        response_lines.extend([
+            "",
+            "## 💡 Quick Start:",
+        ])
+        
+        if "cursor" in profiles:
+            response_lines.extend([
+                "**For Cursor:**",
+                "1. Restart Cursor to load the NIA MCP server",
+                "2. Run `list_repositories` to verify connection",
+                "3. Start indexing with `index_repository https://github.com/owner/repo`",
+                ""
+            ])
+        
+        if "vscode" in profiles:
+            response_lines.extend([
+                "**For VSCode:**",
+                "1. Reload the VSCode window (Cmd/Ctrl+R)",
+                "2. Open command palette (Cmd/Ctrl+Shift+P)",
+                "3. Run 'NIA: Index Repository' task",
+                ""
+            ])
+        
+        if "claude" in profiles:
+            response_lines.extend([
+                "**For Claude Desktop:**",
+                "1. The .claude directory has been created",
+                "2. Claude will now understand NIA commands",
+                "3. Try: 'Search for authentication patterns'",
+                ""
+            ])
+        
+        # Add general tips
+        response_lines.extend([
+            "## 📚 Tips:",
+            "- Use natural language for searches: 'How does X work?'",
+            "- Index repositories before searching them",
+            "- Use `nia_web_search` to discover new repositories",
+            "- Check `list_repositories` to see what's already indexed",
+            "",
+            "Ready to supercharge your development with AI-powered code search! 🚀"
+        ])
+        
+        return [TextContent(
+            type="text",
+            text="\n".join(response_lines)
+        )]
+        
+    except Exception as e:
+        logger.error(f"Error in initialize_project tool: {e}")
+        return [TextContent(
+            type="text",
+            text=f"❌ Error initializing project: {str(e)}\n\n"
+                 "Please check:\n"
+                 "- The project_root path is correct and accessible\n"
+                 "- You have write permissions to the directory\n"
+                 "- The NIA MCP server is properly installed"
+        )]
+
 # Resources
 
 # Note: FastMCP doesn't have list_resources or read_resource decorators

{nia_mcp_server-1.0.5.dist-info → nia_mcp_server-1.0.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nia-mcp-server
-Version: 1.0.5
+Version: 1.0.6
 Summary: NIA Knowledge Agent - MCP server for intelligent codebase search
 Project-URL: Homepage, https://trynia.ai
 Project-URL: Documentation, https://docs.trynia.ai

nia_mcp_server-1.0.6.dist-info/RECORD

@@ -0,0 +1,12 @@
+nia_mcp_server/__init__.py,sha256=xrM4qDGEvxPXQYqVksy08mhmfAj0wIljhJPnYZYHea8,84
+nia_mcp_server/__main__.py,sha256=XY11ESL4hctu-BBgtPATFZyd1o-O7wE7y-UOSoNs-hw,152
+nia_mcp_server/api_client.py,sha256=dk9FkMljuekyjIw7Ij3athsoVNnu7E2b1l2xi2XtB1Y,24255
+nia_mcp_server/profiles.py,sha256=2DD8PFRr5Ij4IK4sPUz0mH8aKjkrEtkKLC1R0iki2bA,7221
+nia_mcp_server/project_init.py,sha256=Mtxvlg7FfdWumc2AdMXifht3V1b6sZvX4b7USbbwMvw,7152
+nia_mcp_server/rule_transformer.py,sha256=wCxoQ1Kl_rI9mUFnh9kG5iCXYU4QInrmFQOReZfAFVo,11000
+nia_mcp_server/server.py,sha256=B6aLTXkX2Mq5eBqDCV_WTumqtSm4bzDf2bHPVyVsgcA,59579
+nia_mcp_server-1.0.6.dist-info/METADATA,sha256=hN6ls8aDU9h83JuQ3AZ8VfLBsrKIVLGt-annSRXHbS8,6910
+nia_mcp_server-1.0.6.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+nia_mcp_server-1.0.6.dist-info/entry_points.txt,sha256=V74FQEp48pfWxPCl7B9mihtqvIJNVjCSbRfCz4ww77I,64
+nia_mcp_server-1.0.6.dist-info/licenses/LICENSE,sha256=5jUPBVkZEicxSAZ91jOO7i8zXEPAHS6M0w8SSf6DftI,1071
+nia_mcp_server-1.0.6.dist-info/RECORD,,

nia_mcp_server-1.0.5.dist-info/RECORD

@@ -1,9 +0,0 @@
-nia_mcp_server/__init__.py,sha256=P3fqcVlJ9fp8ojx6xaX5lrdUNO8rkc8bGYEv8Qm3SAw,84
-nia_mcp_server/__main__.py,sha256=XY11ESL4hctu-BBgtPATFZyd1o-O7wE7y-UOSoNs-hw,152
-nia_mcp_server/api_client.py,sha256=E7x6W2zvFrfyR8yfk8X4z6WGF6wQk_EP4TfQhZAV_4w,20932
-nia_mcp_server/server.py,sha256=UJaP4Q7xlZt_xW4bDD17AgYhwAZ2sZaoTZ6nf_2mNOE,48694
-nia_mcp_server-1.0.5.dist-info/METADATA,sha256=lyWMV-006_5q1vb_aEnHWwUE8lAYcZMpbL9ypEi5kiI,6910
-nia_mcp_server-1.0.5.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-nia_mcp_server-1.0.5.dist-info/entry_points.txt,sha256=V74FQEp48pfWxPCl7B9mihtqvIJNVjCSbRfCz4ww77I,64
-nia_mcp_server-1.0.5.dist-info/licenses/LICENSE,sha256=5jUPBVkZEicxSAZ91jOO7i8zXEPAHS6M0w8SSf6DftI,1071
-nia_mcp_server-1.0.5.dist-info/RECORD,,