nia-mcp-server 1.0.5__py3-none-any.whl → 1.0.7__py3-none-any.whl

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 / "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