mcp-server-code-assist 0.1.0__py3-none-any.whl

mcp_server_code_assist/__init__.py

@@ -0,0 +1,24 @@
+import click
+from pathlib import Path
+import logging
+import sys
+from .server import serve
+
+@click.command()
+@click.option("--working-dir", "-w", type=Path, help="Working directory path")
+@click.option("-v", "--verbose", count=True)
+def main(working_dir: Path | None, verbose: bool) -> None:
+    """MCP Code Assist Server - Code operations for MCP"""
+    import asyncio
+
+    logging_level = logging.WARN
+    if verbose == 1:
+        logging_level = logging.INFO
+    elif verbose >= 2:
+        logging_level = logging.DEBUG
+
+    logging.basicConfig(level=logging_level, stream=sys.stderr)
+    asyncio.run(serve(working_dir))
+
+if __name__ == "__main__":
+    main()

mcp_server_code_assist/__main__.py

@@ -0,0 +1,3 @@
+from mcp_server_code_assist import main
+
+main()

mcp_server_code_assist/schema.xsd

@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+    <xs:element name="instruction">
+        <xs:complexType>
+            <xs:sequence>
+                <xs:element name="function">
+                    <xs:simpleType>
+                        <xs:restriction base="xs:string">
+                            <xs:enumeration value="create"/>
+                            <xs:enumeration value="delete"/>
+                            <xs:enumeration value="modify"/>
+                            <xs:enumeration value="rewrite"/>
+                        </xs:restriction>
+                    </xs:simpleType>
+                </xs:element>
+                <xs:element name="path" type="xs:string"/>
+                <xs:element name="content" type="xs:string" minOccurs="0"/>
+                <xs:element name="replacements" minOccurs="0">
+                    <xs:complexType>
+                        <xs:sequence>
+                            <xs:any processContents="skip" minOccurs="0" maxOccurs="unbounded"/>
+                        </xs:sequence>
+                    </xs:complexType>
+                </xs:element>
+            </xs:sequence>
+        </xs:complexType>
+    </xs:element>
+</xs:schema>

mcp_server_code_assist/server.py

@@ -0,0 +1,240 @@
+import logging
+import os
+from pathlib import Path
+from typing import Any
+from enum import Enum
+from mcp.server import Server 
+from mcp.server.session import ServerSession
+from mcp.server.stdio import stdio_server
+from mcp.types import ClientCapabilities, TextContent, Tool, ListRootsResult, RootsCapability
+import git
+from mcp_server_code_assist.tools.models import (
+    FileCreate, FileDelete, FileModify, FileRewrite,
+    GitBase, GitAdd, GitCommit, GitDiff, GitCreateBranch,
+    GitCheckout, GitShow, GitLog
+)
+from mcp_server_code_assist.tools.file_tools import FileTools
+from mcp_server_code_assist.tools.git_functions import git_status, git_diff_unstaged, git_diff_staged, git_diff, git_log, git_show
+
+class CodeAssistTools(str, Enum):
+    FILE_CREATE = "file_create"
+    FILE_DELETE = "file_delete" 
+    FILE_MODIFY = "file_modify"
+    FILE_REWRITE = "file_rewrite"
+    GIT_STATUS = "git_status"
+    GIT_DIFF_UNSTAGED = "git_diff_unstaged"
+    GIT_DIFF_STAGED = "git_diff_staged"
+    GIT_DIFF = "git_diff"
+    GIT_COMMIT = "git_commit"
+    GIT_ADD = "git_add"
+    GIT_RESET = "git_reset"
+    GIT_LOG = "git_log"
+    GIT_CREATE_BRANCH = "git_create_branch"
+    GIT_CHECKOUT = "git_checkout"
+    GIT_SHOW = "git_show"
+
+async def process_instruction(instruction: dict[str, Any], repo_path: Path) -> dict[str, Any]:
+    FileTools.init_allowed_paths([str(repo_path)])
+    try:
+        match instruction['type']:
+            case 'read_file':
+                path = str(repo_path / instruction['path'])
+                content = await FileTools.read_file(path)
+                return {'content': content}
+            
+            case 'read_multiple':
+                paths = [str(repo_path / p) for p in instruction['paths']]
+                contents = await FileTools.read_multiple_files(paths)
+                contents_dict = {os.path.basename(k): v for k,v in contents.items()}
+                return {'contents': contents_dict}
+            
+            case 'create_file':
+                path = str(repo_path / instruction['path'])
+                result = await FileTools.create_file(path, instruction.get('content', ''))
+                return {'result': result}
+                
+            case 'modify_file':
+                path = str(repo_path / instruction['path'])
+                result = await FileTools.modify_file(path, instruction['replacements'])
+                return {'result': result}
+                
+            case 'rewrite_file':
+                path = str(repo_path / instruction['path'])
+                result = await FileTools.rewrite_file(path, instruction['content'])
+                return {'result': result}
+                
+            case 'delete_file':
+                path = str(repo_path / instruction['path'])
+                result = await FileTools.delete_file(path)
+                return {'result': result}
+            
+            case _:
+                return {'error': 'Invalid instruction type'}
+
+    except Exception as e:
+        return {'error': str(e)}
+
+async def serve(working_dir: Path | None) -> None:
+    logger = logging.getLogger(__name__)
+    server = Server("mcp-code-assist")
+
+    @server.list_tools()
+    async def list_tools() -> list[Tool]:
+        return [
+            Tool(
+                name=CodeAssistTools.FILE_CREATE,
+                description="Creates a new file with content",
+                inputSchema=FileCreate.schema(),
+            ),
+            Tool(
+                name=CodeAssistTools.FILE_DELETE,
+                description="Deletes a file",
+                inputSchema=FileDelete.schema(),
+            ),
+            Tool(
+                name=CodeAssistTools.FILE_MODIFY,
+                description="Modifies file content using search/replace",
+                inputSchema=FileModify.schema(),
+            ),
+            Tool(
+                name=CodeAssistTools.FILE_REWRITE,
+                description="Rewrites entire file content",
+                inputSchema=FileRewrite.schema(),
+            ),
+            Tool(
+                name=CodeAssistTools.GIT_STATUS,
+                description="Shows the working tree status",
+                inputSchema=GitBase.schema(),
+            ),
+            Tool(
+                name=CodeAssistTools.GIT_DIFF_UNSTAGED,
+                description="Shows changes in the working directory that are not yet staged",
+                inputSchema=GitBase.schema(),
+            ),
+            Tool(
+                name=CodeAssistTools.GIT_DIFF_STAGED,
+                description="Shows changes that are staged for commit",
+                inputSchema=GitBase.schema(),
+            ),
+            Tool(
+                name=CodeAssistTools.GIT_DIFF,
+                description="Shows differences between branches or commits",
+                inputSchema=GitDiff.schema(),
+            ),
+            Tool(
+                name=CodeAssistTools.GIT_COMMIT,
+                description="Records changes to the repository",
+                inputSchema=GitCommit.schema(),
+            ),
+            Tool(
+                name=CodeAssistTools.GIT_ADD,
+                description="Adds file contents to the staging area",
+                inputSchema=GitAdd.schema(),
+            ),
+            Tool(
+                name=CodeAssistTools.GIT_RESET,
+                description="Unstages all staged changes",
+                inputSchema=GitBase.schema(),
+            ),
+            Tool(
+                name=CodeAssistTools.GIT_LOG,
+                description="Shows the commit logs",
+                inputSchema=GitLog.schema(),
+            ),
+            Tool(
+                name=CodeAssistTools.GIT_CREATE_BRANCH,
+                description="Creates a new branch from an optional base branch",
+                inputSchema=GitCreateBranch.schema(),
+            ),
+            Tool(
+                name=CodeAssistTools.GIT_CHECKOUT,
+                description="Switches branches",
+                inputSchema=GitCheckout.schema(),
+            ),
+            Tool(
+                name=CodeAssistTools.GIT_SHOW,
+                description="Shows the contents of a commit",
+                inputSchema=GitShow.schema(),
+            ),
+        ]
+
+    @server.call_tool()
+    async def call_tool(name: str, arguments: dict) -> list[TextContent]:
+        match name:
+            case CodeAssistTools.FILE_CREATE:
+                result = await FileTools.create_file(arguments["path"], arguments.get("content", ""))
+                return [TextContent(type="text", text=result)]
+
+            case CodeAssistTools.FILE_DELETE:
+                result = await FileTools.delete_file(arguments["path"])
+                return [TextContent(type="text", text=result)]
+
+            case CodeAssistTools.FILE_MODIFY:
+                result = await FileTools.modify_file(arguments["path"], arguments["replacements"])
+                return [TextContent(type="text", text=result)]
+
+            case CodeAssistTools.FILE_REWRITE:
+                result = await FileTools.rewrite_file(arguments["path"], arguments["content"])
+                return [TextContent(type="text", text=result)]
+
+            case CodeAssistTools.GIT_STATUS:
+                repo = git.Repo(arguments["repo_path"])
+                status = git_status(repo)
+                return [TextContent(type="text", text=f"Repository status:\n{status}")]
+
+            case CodeAssistTools.GIT_DIFF_UNSTAGED:
+                repo = git.Repo(arguments["repo_path"])
+                diff = git_diff_unstaged(repo)
+                return [TextContent(type="text", text=f"Unstaged changes:\n{diff}")]
+
+            case CodeAssistTools.GIT_DIFF_STAGED:
+                repo = git.Repo(arguments["repo_path"])
+                diff = git_diff_staged(repo)
+                return [TextContent(type="text", text=f"Staged changes:\n{diff}")]
+
+            case CodeAssistTools.GIT_DIFF:
+                repo = git.Repo(arguments["repo_path"])
+                diff = git_diff(repo, arguments["target"])
+                return [TextContent(type="text", text=f"Diff with {arguments['target']}:\n{diff}")]
+
+            case CodeAssistTools.GIT_COMMIT:
+                repo = git.Repo(arguments["repo_path"])
+                result = git_commit(repo, arguments["message"])
+                return [TextContent(type="text", text=result)]
+
+            case CodeAssistTools.GIT_ADD:
+                repo = git.Repo(arguments["repo_path"])
+                result = git_add(repo, arguments["files"])
+                return [TextContent(type="text", text=result)]
+
+            case CodeAssistTools.GIT_RESET:
+                repo = git.Repo(arguments["repo_path"])
+                result = git_reset(repo)
+                return [TextContent(type="text", text=result)]
+
+            case CodeAssistTools.GIT_LOG:
+                repo = git.Repo(arguments["repo_path"])
+                log = git_log(repo, arguments.get("max_count", 10))
+                return [TextContent(type="text", text="Commit history:\n" + "\n".join(log))]
+
+            case CodeAssistTools.GIT_CREATE_BRANCH:
+                repo = git.Repo(arguments["repo_path"])
+                result = git_create_branch(repo, arguments["branch_name"], arguments.get("base_branch"))
+                return [TextContent(type="text", text=result)]
+
+            case CodeAssistTools.GIT_CHECKOUT:
+                repo = git.Repo(arguments["repo_path"])
+                result = git_checkout(repo, arguments["branch_name"])
+                return [TextContent(type="text", text=result)]
+
+            case CodeAssistTools.GIT_SHOW:
+                repo = git.Repo(arguments["repo_path"])
+                result = git_show(repo, arguments["revision"])
+                return [TextContent(type="text", text=result)]
+
+            case _:
+                raise ValueError(f"Unknown tool: {name}")
+
+    options = server.create_initialization_options()
+    async with stdio_server() as (read_stream, write_stream):
+        await server.run(read_stream, write_stream, options, raise_exceptions=True)

mcp_server_code_assist/tools/file_tools.py

@@ -0,0 +1,220 @@
+from pathlib import Path
+import os
+import shutil
+import difflib
+import fnmatch
+import json
+from typing import Union, Dict, Tuple, Optional, Set
+import git
+
+class FileTools:
+    _allowed_paths: list[str] = []
+
+    @classmethod
+    def init_allowed_paths(cls, paths: list[str]):
+        cls._allowed_paths = [os.path.abspath(p) for p in paths]
+
+    @classmethod
+    async def validate_path(cls, path: str) -> str:
+        abs_path = os.path.abspath(path)
+        if not any(abs_path.startswith(p) for p in cls._allowed_paths):
+            raise ValueError(f"Path {path} is outside allowed directories")
+        return abs_path
+
+    @classmethod
+    async def read_file(cls, path: str) -> str:
+        path = await cls.validate_path(path)
+        return Path(path).read_text()
+
+    @classmethod
+    async def write_file(cls, path: str, content: str) -> None:
+        path = await cls.validate_path(path)
+        Path(path).parent.mkdir(parents=True, exist_ok=True)
+        Path(path).write_text(content)
+
+    @classmethod
+    async def read_multiple_files(cls, paths: list[str]) -> Dict[str, str]:
+        result = {}
+        for path in paths:
+            try:
+                content = await cls.read_file(path)
+                result[path] = content
+            except Exception as e:
+                result[path] = str(e)
+        return result
+
+    @classmethod
+    async def create_file(cls, path: str, content: str = "") -> str:
+        await cls.write_file(path, content)
+        return f"Created file: {path}"
+        
+    @classmethod
+    async def delete_file(cls, path: str) -> str:
+        path = await cls.validate_path(path)
+        path_obj = Path(path)
+        if path_obj.is_file():
+            path_obj.unlink()
+            return f"Deleted file: {path}"
+        elif path_obj.is_dir():
+            shutil.rmtree(path)
+            return f"Deleted directory: {path}"
+        return f"Path not found: {path}"
+
+    @classmethod
+    async def modify_file(cls, path: str, replacements: Dict[str, str]) -> str:
+        path = await cls.validate_path(path)
+        content = await cls.read_file(path)
+        original = content
+        
+        for old, new in replacements.items():
+            content = content.replace(old, new)
+            
+        await cls.write_file(path, content)
+        return cls.generate_diff(original, content)
+
+    @classmethod
+    async def rewrite_file(cls, path: str, content: str) -> str:
+        path = await cls.validate_path(path)
+        original = await cls.read_file(path) if Path(path).exists() else ""
+        await cls.write_file(path, content)
+        return cls.generate_diff(original, content)
+
+    @staticmethod
+    def generate_diff(original: str, modified: str) -> str:
+        diff = difflib.unified_diff(
+            original.splitlines(keepends=True),
+            modified.splitlines(keepends=True),
+            fromfile='original',
+            tofile='modified'
+        )
+        return ''.join(diff)
+
+    @classmethod
+    async def list_directory(cls, path: str) -> list[str]:
+        path = await cls.validate_path(path)
+        entries = []
+        for item in Path(path).iterdir():
+            entries.append(str(item))
+        return entries
+
+    @classmethod
+    async def create_directory(cls, path: str) -> None:
+        path = await cls.validate_path(path)
+        Path(path).mkdir(parents=True, exist_ok=True)
+
+    @classmethod
+    def _load_gitignore(cls, path: str) -> list[str]:
+        gitignore_path = os.path.join(path, ".gitignore")
+        patterns = []
+        if os.path.exists(gitignore_path):
+            with open(gitignore_path, 'r') as f:
+                for line in f:
+                    line = line.strip()
+                    if line and not line.startswith('#'):
+                        patterns.append(line)
+        return patterns
+
+    @classmethod
+    def _get_tracked_files(cls, repo_path: str) -> Optional[Set[str]]:
+        try:
+            repo = git.Repo(repo_path)
+            return set(repo.git.ls_files().splitlines())
+        except git.exc.InvalidGitRepositoryError:
+            return None
+
+    @classmethod
+    async def directory_tree(cls, path: str) -> Tuple[str, int, int]:
+        path = await cls.validate_path(path)
+        base_path = Path(path)
+
+        # Try git tracking first
+        tracked_files = cls._get_tracked_files(path)
+        gitignore = cls._load_gitignore(path) if tracked_files is None else []
+        
+        def gen_tree(path: Path, prefix: str = "") -> Tuple[list[str], int, int]:
+            entries = []
+            dir_count = 0
+            file_count = 0
+            
+            items = sorted(path.iterdir(), key=lambda x: (x.is_file(), x.name))
+            for i, item in enumerate(items):
+                rel_path = str(item.relative_to(base_path))
+
+                # Skip if file should be ignored
+                if tracked_files is not None:
+                    if rel_path not in tracked_files and not any(str(p.relative_to(base_path)) in tracked_files for p in item.rglob("*") if p.is_file()):
+                        continue
+                else:  
+                    # Use gitignore
+                    if cls._should_ignore(rel_path, gitignore):
+                        continue
+                    
+                is_last = i == len(items) - 1
+                curr_prefix = "└── " if is_last else "├── "
+                curr_line = prefix + curr_prefix + item.name
+                
+                if item.is_dir():
+                    next_prefix = prefix + ("    " if is_last else "│   ")
+                    subtree, sub_dirs, sub_files = gen_tree(item, next_prefix)
+                    if tracked_files is not None and not subtree:
+                        continue
+                    entries.extend([curr_line] + subtree)
+                    dir_count += 1 + sub_dirs
+                    file_count += sub_files
+                else:
+                    if tracked_files is not None and rel_path not in tracked_files:
+                        continue
+                    entries.append(curr_line)
+                    file_count += 1
+                    
+            return entries, dir_count, file_count
+            
+        tree_lines, total_dirs, total_files = gen_tree(Path(path))
+        return "\n".join(tree_lines), total_dirs, total_files
+
+    @classmethod
+    def _should_ignore(cls, path: str, patterns: list[str]) -> bool:
+        if not patterns:
+            return False
+
+        parts = Path(path).parts
+        for pattern in patterns:
+            pattern = pattern.strip()
+            if not pattern or pattern.startswith('#'):
+                continue
+
+            if pattern.endswith('/'):
+                pattern = pattern.rstrip('/')
+                if pattern in parts:
+                    return True
+            else:
+                if fnmatch.fnmatch(parts[-1], pattern):  # Match basename
+                    return True
+                # Match full path
+                if fnmatch.fnmatch(path, pattern):
+                    return True
+
+        return False
+
+    @classmethod
+    async def search_files(cls, path: str, pattern: str, excludes: Optional[list[str]] = None) -> list[str]:
+        path = await cls.validate_path(path)
+        gitignore = cls._load_gitignore(path)
+        if excludes:
+            gitignore.extend(excludes)
+            
+        results = []
+        for root, _, files in os.walk(path):
+            rel_root = os.path.relpath(root, path)
+            if rel_root != "." and cls._should_ignore(rel_root, gitignore):
+                continue
+                
+            for file in files:
+                rel_path = os.path.join(rel_root, file)
+                if rel_path != "." and cls._should_ignore(rel_path, gitignore):
+                    continue
+                    
+                if pattern in file or fnmatch.fnmatch(file, pattern):
+                    results.append(os.path.join(root, file))
+                    
+        return results

mcp_server_code_assist/tools/git_functions.py

@@ -0,0 +1,25 @@
+import git
+
+def git_status(repo: git.Repo) -> str:
+    return repo.git.status()
+
+def git_diff_unstaged(repo: git.Repo) -> str:
+    return repo.git.diff()
+
+def git_diff_staged(repo: git.Repo) -> str:
+    return repo.git.diff("--cached")
+
+def git_diff(repo: git.Repo, target: str) -> str:
+    return repo.git.diff(target)
+
+def git_log(repo: git.Repo, max_count: int = 10) -> str:
+    commits = list(repo.iter_commits(max_count=max_count))
+    log = []
+    for commit in commits:
+        log.append(f"Commit: {commit.hexsha}\nAuthor: {commit.author}\nDate: {commit.authored_datetime}\nMessage: {commit.message}\n")
+    return "\n".join(log)
+
+def git_show(repo: git.Repo, revision: str) -> str:
+    commit = repo.commit(revision)
+    output = [f"Commit: {commit.hexsha}\nAuthor: {commit.author}\nDate: {commit.authored_datetime}\nMessage: {commit.message}\n"]
+    return "".join(output)

mcp_server_code_assist/tools/invoke.py

@@ -0,0 +1,7 @@
+"""Function invocation helper."""
+from typing import Dict, Any
+
+def invoke_git(function: str, params: Dict[str, Any]) -> str:
+    """Invokes a git function with given parameters."""
+    # Functions will be invoked via the assistant
+    return f"git_{function}({', '.join(f'{k}={v!r}' for k,v in params.items())})"

mcp_server_code_assist/tools/models.py

@@ -0,0 +1,48 @@
+from typing import Union, Optional
+from pydantic import BaseModel
+from pathlib import Path
+
+class FileCreate(BaseModel):
+    path: Union[str, Path]
+    content: str = ""
+
+class FileDelete(BaseModel):
+    path: Union[str, Path]
+
+class FileModify(BaseModel):
+    path: Union[str, Path]
+    replacements: dict[str, str]
+
+class FileRewrite(BaseModel):
+    path: Union[str, Path]
+    content: str
+
+class GitBase(BaseModel):
+    repo_path: str
+
+class GitAdd(GitBase):
+    files: list[str]
+
+class GitCommit(GitBase):
+    message: str
+
+class GitDiff(GitBase):
+    target: str
+
+class GitCreateBranch(GitBase):
+    branch_name: str
+    base_branch: Optional[str] = None
+
+class GitCheckout(GitBase):
+    branch_name: str
+
+class GitShow(GitBase):
+    revision: str
+
+class GitLog(GitBase):
+    max_count: int = 10
+
+class RepositoryOperation(BaseModel):
+    path: str
+    content: Optional[str] = None
+    replacements: Optional[dict[str, str]] = None

mcp_server_code_assist/tools/repository_tools.py

@@ -0,0 +1,76 @@
+from pathlib import Path
+from git import Repo
+import aiofiles
+from typing import Optional
+
+class RepositoryTools:
+    def __init__(self, repo_path: str):
+        self.path = Path(repo_path).resolve()
+        if not self.path.exists():
+            raise ValueError(f"Invalid repository path: {repo_path}")
+        self.repo = Repo(self.path)
+
+    async def read_file(self, path: str) -> str:
+        file_path = self.path / path
+        async with aiofiles.open(file_path, 'r') as f:
+            return await f.read()
+            
+    async def read_multiple(self, paths: list[str]) -> dict[str, str]:
+        contents = {}
+        for path in paths:
+            contents[path] = await self.read_file(path)
+        return contents
+        
+    async def create_file(self, path: str, content: str = '') -> None:
+        file_path = self.path / path
+        file_path.parent.mkdir(parents=True, exist_ok=True)
+        async with aiofiles.open(file_path, 'w') as f:
+            await f.write(content)
+            
+    async def modify_file(self, path: str, replacements: dict[str, str]) -> None:
+        file_path = self.path / path
+        content = await self.read_file(path)
+        for old, new in replacements.items():
+            content = content.replace(old, new)
+        await self.rewrite_file(path, content)
+            
+    async def rewrite_file(self, path: str, content: str) -> None:
+        file_path = self.path / path
+        async with aiofiles.open(file_path, 'w') as f:
+            await f.write(content)
+            
+    async def delete_file(self, path: str) -> None:
+        file_path = self.path / path
+        file_path.unlink()
+        
+    def status(self) -> str:
+        return self.repo.git.status()
+        
+    def add(self, files: list[str]) -> str:
+        return self.repo.git.add(files)
+        
+    def commit(self, message: str) -> str:
+        return self.repo.git.commit('-m', message)
+
+    def diff_unstaged(self) -> str:
+        return self.repo.git.diff()
+    
+    def diff_staged(self) -> str:
+        return self.repo.git.diff('--cached')
+    
+    def diff(self, target: str) -> str:
+        return self.repo.git.diff(target)
+        
+    def checkout(self, branch_name: str) -> str:
+        return self.repo.git.checkout(branch_name)
+        
+    def create_branch(self, branch_name: str, base_branch: Optional[str] = None) -> str:
+        if base_branch:
+            return self.repo.git.branch(branch_name, base_branch)
+        return self.repo.git.branch(branch_name)
+
+    def log(self, max_count: int = 10) -> str:
+        return self.repo.git.log(f'-n {max_count}')
+
+    def show(self, revision: str) -> str:
+        return self.repo.git.show(revision)

mcp_server_code_assist/xml_parser.py

@@ -0,0 +1,48 @@
+import xml.etree.ElementTree as ET
+from pathlib import Path
+import xmlschema
+import re
+
+class XMLProcessor:
+    def __init__(self):
+        schema_path = Path(__file__).parent / "schema.xsd"
+        self.validator = xmlschema.XMLSchema(schema_path)
+
+    def _normalize_text(self, text: str) -> str:
+        """Normalize whitespace in text content"""
+        return re.sub(r'\s+', ' ', text).strip()
+
+    def parse(self, xml_str: str) -> dict[str, str | dict[str, str]]:
+        root = ET.fromstring(self._normalize_text(xml_str))
+        self.validator.validate(root)
+        
+        result = {
+            "function": self._normalize_text(root.find("function").text),
+            "path": self._normalize_text(root.find("path").text),
+        }
+
+        if (content_elem := root.find("content")) is not None:
+            result["content"] = self._normalize_text(content_elem.text)
+            
+        if (replacements_elem := root.find("replacements")) is not None:
+            result["replacements"] = {
+                elem.tag: self._normalize_text(elem.text)
+                for elem in replacements_elem
+            }
+            
+        return result
+
+    def generate(self, data: dict[str, str | dict[str, str]]) -> str:
+        root = ET.Element("instruction")
+        ET.SubElement(root, "function").text = data["function"]
+        ET.SubElement(root, "path").text = data["path"]
+        
+        if "content" in data:
+            ET.SubElement(root, "content").text = data["content"]
+            
+        if "replacements" in data:
+            replacements = ET.SubElement(root, "replacements")
+            for key, value in data["replacements"].items():
+                ET.SubElement(replacements, key).text = value
+                
+        return f'<?xml version="1.0"?>\n{ET.tostring(root, encoding="unicode")}'

mcp_server_code_assist-0.1.0.dist-info/METADATA

@@ -0,0 +1,11 @@
+Metadata-Version: 2.4
+Name: mcp-server-code-assist
+Version: 0.1.0
+Summary: MCP Code Assist Server
+Requires-Python: >=3.11
+Requires-Dist: aiofiles>=24.0.0
+Requires-Dist: gitpython>=3.1.40
+Requires-Dist: pydantic>=2.0.0
+Provides-Extra: test
+Requires-Dist: pytest-asyncio>=0.25.0; extra == 'test'
+Requires-Dist: pytest>=8.0.0; extra == 'test'

mcp_server_code_assist-0.1.0.dist-info/RECORD

@@ -0,0 +1,14 @@
+mcp_server_code_assist/__init__.py,sha256=Aai1h9YUGDDWQn9rsHq5gCZXO7QCQs2pJtyGC9mYV0o,661
+mcp_server_code_assist/__main__.py,sha256=lbLwix6a0gDF7YKoqbXF88oTdmr8KQGKWchLKEIn5SU,47
+mcp_server_code_assist/schema.xsd,sha256=vtfQQDzCHvbILT78zF_53N-68GrJRbELg1Xgq3Uu9DE,1235
+mcp_server_code_assist/server.py,sha256=qtz9pD3_JxIJGare5Sal25E8DafZY-DX4thrghulT1s,10012
+mcp_server_code_assist/xml_parser.py,sha256=FMmcAk7PbnTNidBGUynq6ZbUs1O9OHHI298REAQEMqw,1827
+mcp_server_code_assist/tools/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mcp_server_code_assist/tools/file_tools.py,sha256=iGdVGP9phD5wMZ5HxbRv3gbUpNx-QF27xDLrUI9wUkU,7978
+mcp_server_code_assist/tools/git_functions.py,sha256=iGIhi8i7BxIrAL8JytWjfcZP7xgla0uVweazSKUNtB4,882
+mcp_server_code_assist/tools/invoke.py,sha256=lYIu5bJYBaKDDVYz6HRqodpLBMnfVpcvgAref10LO2s,313
+mcp_server_code_assist/tools/models.py,sha256=3ZUfzodSVbwSoIKG5oKiLbnjVeptT5QKLaQSwl7McJY,937
+mcp_server_code_assist/tools/repository_tools.py,sha256=5OG4ecmqXVEeuX9U5jdegbQ2So4lxKkIjG3M3e5rgFI,2700
+mcp_server_code_assist-0.1.0.dist-info/METADATA,sha256=JuQfHEwqOIt1x3KF7vY1hsGpmpoXWnGrTndqb-5L4a0,340
+mcp_server_code_assist-0.1.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+mcp_server_code_assist-0.1.0.dist-info/RECORD,,

mcp_server_code_assist-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.27.0
+Root-Is-Purelib: true
+Tag: py3-none-any