mcp-server-code-assist 0.1.0__tar.gz

mcp_server_code_assist-0.1.0/.gitignore

@@ -0,0 +1,3 @@
+__pycache__
+.venv/
+venv/

mcp_server_code_assist-0.1.0/Dockerfile

@@ -0,0 +1,27 @@
+# Use a Python image with uv pre-installed
+FROM ghcr.io/astral-sh/uv:python3.12-bookworm-slim AS uv
+
+WORKDIR /app
+
+ENV UV_COMPILE_BYTECODE=1
+ENV UV_LINK_MODE=copy
+
+RUN --mount=type=cache,target=/root/.cache/uv \
+    --mount=type=bind,source=uv.lock,target=uv.lock \
+    --mount=type=bind,source=pyproject.toml,target=pyproject.toml \
+    uv sync --frozen --no-install-project --no-dev --no-editable
+
+ADD . /app
+RUN --mount=type=cache,target=/root/.cache/uv \
+    uv sync --frozen --no-dev --no-editable
+
+FROM python:3.12-slim-bookworm
+
+WORKDIR /app
+ 
+COPY --from=uv /root/.local /root/.local
+COPY --from=uv --chown=app:app /app/.venv /app/.venv
+
+ENV PATH="/app/.venv/bin:$PATH"
+
+ENTRYPOINT ["mcp-server-code-assist"]

mcp_server_code_assist-0.1.0/License

@@ -0,0 +1,7 @@
+Copyright 2025 Abhishek Bhakat
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

mcp_server_code_assist-0.1.0/PKG-INFO

@@ -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/README.md

@@ -0,0 +1,125 @@
+# mcp-server-code-assist: A Code Assistant MCP Server
+
+## Overview
+
+A Model Context Protocol server for code modification and generation. This server provides tools to create, modify, and delete code via Large Language Models.
+
+### Tools
+
+1. `create`
+   - Creates new files
+   - Input: XML instruction with path and content
+   - Returns: Confirmation of file creation
+
+2. `modify`
+   - Modifies existing files with search/replace
+   - Input: XML instruction with path, search pattern, and new content
+   - Returns: Diff of changes
+
+3. `rewrite`
+   - Completely rewrites a file
+   - Input: XML instruction with path and new content
+   - Returns: Confirmation of rewrite
+
+4. `delete`
+   - Removes files
+   - Input: XML instruction with path
+   - Returns: Confirmation of deletion
+
+### XML Format
+
+```xml
+<Plan>
+Describe approach and reasoning
+</Plan>
+
+<file path="/path/to/file" action="create|modify|rewrite|delete">
+  <change>
+    <description>What this change does</description>
+    <search>
+===
+Original code for modification
+===
+    </search>
+    <content>
+===
+New or modified code
+===
+    </content>
+  </change>
+</file>
+```
+
+## Installation
+
+### Using uv (recommended)
+
+```bash
+uvx mcp-server-code-assist
+```
+
+### Using pip
+
+```bash
+pip install mcp-server-code-assist
+python -m mcp_server_code_assist
+```
+
+## Configuration
+
+### Usage with Claude Desktop
+
+<details>
+<summary>Using uvx</summary>
+
+```json
+"mcpServers": {
+  "code-assist": {
+    "command": "uvx",
+    "args": ["mcp-server-code-assist"]
+  }
+}
+```
+</details>
+
+<details>
+<summary>Using docker</summary>
+
+```json
+"mcpServers": {
+  "code-assist": {
+    "command": "docker",
+    "args": ["run", "--rm", "-i", "--mount", "type=bind,src=/Users/username,dst=/Users/username", "mcp/code-assist"]
+  }
+}
+```
+</details>
+
+### Usage with Zed
+
+Add to settings.json:
+
+```json
+"context_servers": {
+  "mcp-server-code-assist": {
+    "command": {
+      "path": "uvx",
+      "args": ["mcp-server-code-assist"]
+    }
+  }
+},
+```
+
+## Development
+
+```bash
+cd src/code-assist
+uvx mcp-server-code-assist
+
+# For docker:
+docker build -t mcp/code-assist .
+```
+
+## License
+
+MIT License. See LICENSE file for details.

mcp_server_code_assist-0.1.0/calude_prompt.txt

@@ -0,0 +1,8 @@
+Project: MCP Code Assist Server
+Location: /Volumes/Passport616/AI/MCP/src/code-assist
+Branch: code-assist
+
+Claude, let's continue working on our MCP Code Assist Server. Please:
+1. Read /Volumes/Passport616/AI/MCP/src/code-assist/plan.md
+2. Show me what's done and what's next
+3. Let's complete phase 1 properly

mcp_server_code_assist-0.1.0/plan.md

@@ -0,0 +1,88 @@
+# Code Assist MCP Server Implementation Plan
+
+## Project Setup
+- [x] Basic file structure
+- [x] pyproject.toml with dependencies
+- [x] Dockerfile with UV support
+- [x] README.md with usage instructions
+- [x] LICENSE file (MIT)
+- [x] Source package structure
+- [x] __main__.py and __init__.py
+- [x] Tools module structure
+
+## Core Components Implementation
+- [x] XML Parser
+  - [x] Add XML schema validation
+  - [x] Implement parse/generate methods
+  - [x] Add tests
+
+- [x] File Tools
+  - [x] create function
+  - [x] delete function  
+  - [x] modify with search/replace
+  - [x] rewrite function
+  - [x] diff generation
+  - [x] directory tree with gitignore
+  - [x] file search
+  - [x] file operations tests
+
+- [x] Git Operations
+  - [x] Repository tools implementation
+  - [x] GitPython integration
+  - [x] Status/Diff/Log operations
+  - [x] Add/Commit operations
+  - [x] Branch operations
+  - [x] Tests for git operations
+
+- [ ] Server
+  - [ ] OpenRouter integration
+  - [ ] Command line interface
+  - [ ] XML instruction processing
+  - [x] Basic request handlers
+  - [x] Error handling
+  - [x] Request validation
+  - [x] Tests for file operations
+
+## Testing Infrastructure  
+- [x] Unit test suite setup
+- [x] Integration test cases
+- [x] Fixtures and test data
+- [x] GitPython test fixtures
+
+## Documentation
+- [ ] API documentation
+- [ ] Example XML files
+- [ ] Configuration examples
+- [x] Git operations guide
+
+## System Design Challenges
+
+### Context Length Limitation
+Problem: LLMs have limited context length ("memory"). Multiple file changes or complex refactoring can exceed this limit.
+
+Proposed Solutions:
+- Make operations idempotent (retryable without side effects)
+- Break large changes into atomic, self-contained operations
+- Use git commits as checkpoints
+- Store intermediate state in temporary files
+- Design instruction format to be resumable
+
+## Current Task
+Phase 1: Read-only operations
+- File read operations complete
+- Git read operations complete
+- File write operations to be implemented directly
+
+Phase 2:
+- OpenRouter integration
+
+Phase 3: Write operations
+- For git write operations (add, commit, reset, branch, checkout), Claude provides commands to user by making an API call to openrouter.
+
+
+## Notes
+- XML format for instructions defined and documented
+- Using Python 3.12 with UV package manager
+- Following MCP server patterns from git implementation
+- Local development setup complete with tests
+- GitPython used for repository operations

mcp_server_code_assist-0.1.0/pyproject.toml

@@ -0,0 +1,25 @@
+[project]
+name = "mcp-server-code-assist"
+version = "0.1.0"
+description = "MCP Code Assist Server"
+requires-python = ">=3.11"
+dependencies = [
+    "aiofiles>=24.0.0",
+    "gitpython>=3.1.40",
+    "pydantic>=2.0.0"
+]
+
+[project.optional-dependencies]
+test = [
+    "pytest>=8.0.0",
+    "pytest-asyncio>=0.25.0"
+]
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.pytest.ini_options]
+pythonpath = ["src"]
+asyncio_mode = "strict"
+testpaths = ["tests"]

mcp_server_code_assist-0.1.0/src/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-0.1.0/src/mcp_server_code_assist/__main__.py

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

mcp_server_code_assist-0.1.0/src/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-0.1.0/src/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)