glide-mcp 0.1.1__py3-none-any.whl

glide_mcp-0.1.1.dist-info/METADATA

@@ -0,0 +1,67 @@
+Metadata-Version: 2.4
+Name: glide-mcp
+Version: 0.1.1
+Summary: mcp server that tries to save you from git troubles
+License-File: LICENSE
+Requires-Python: >=3.13
+Requires-Dist: black>=25.9.0
+Requires-Dist: cerebras-cloud-sdk>=1.56.1
+Requires-Dist: fastmcp>=2.12.5
+Requires-Dist: helix-py>=0.2.30
+Requires-Dist: numpy>=2.3.4
+Requires-Dist: pytest-asyncio>=1.2.0
+Requires-Dist: pytest>=8.4.2
+Requires-Dist: python-dotenv>=1.1.1
+Description-Content-Type: text/markdown
+
+## How to Use
+
+### 1. Clone the repository
+
+```bash
+git clone https://github.com/SoarAILabs/glide.git
+```
+
+### 2. Navigate to the project directory
+
+```bash
+cd glide
+```
+
+### 3. Start the server
+
+```bash
+uv run python -m src.mcp.app
+```
+
+> **Note:** Currently, only [Cursor](https://www.cursor.so/) is supported as the MCP Client.
+
+### 4. Configure Cursor to use your local MCP server
+
+**One-Click Install:**
+
+[![Install MCP Server](https://cursor.com/deeplink/mcp-install-dark.svg)](https://cursor.com/en-US/install-mcp?name=glide&config=eyJjb21tYW5kIjoidXYgcnVuIC0tZGlyZWN0b3J5IFBBVEhcXHRvXFx5b3VyXFxnbGlkZVxcZGlyZWN0b3J5IHB5dGhvbiAtbSBzcmMubWNwLmFwcCJ9)
+
+**Manual Installation:**
+
+Add the following to your `mcp.json` configuration in Cursor:
+
+```json
+{
+  "mcpServers": {
+    "glide": {
+      "url": "http://127.0.0.1:8000/mcp"
+    }
+  }
+}
+```
+
+> **Note:** The port (`8000` above) is just an example.  
+> To use a different port, open `src/mcp/app.py` and update the following lines accordingly:
+
+```python
+if __name__ == "__main__":
+    mcp.run(transport="streamable-http", host="127.0.0.1", port=8000)
+```
+
+Replace `8000` with your desired port number.

glide_mcp-0.1.1.dist-info/RECORD

@@ -0,0 +1,9 @@
+src/core/LLM/cerebras_inference.py,sha256=zO4ff4Urhk195gQvZouXYWhtz8P-gSJJAzWzdUjvkTQ,3481
+src/kite_exclusive/commit_splitter/prompts/prompt1.md,sha256=eOTX0H_n0vOuyfanEvbC8MAj4pF7W7FMiCdJw3zSL5g,1255
+src/kite_exclusive/commit_splitter/services/voyage_service.py,sha256=dgAMRypj2uHhDJOJx-dE4bKvRawiApHKbuHOvbNBTLE,1639
+src/mcp/app.py,sha256=JeRldSYEroigMKdLZTAY9Sz-Q1nHgryT26mrvyGzi60,21131
+glide_mcp-0.1.1.dist-info/METADATA,sha256=fLblWuESXH_7xznuEfTczj5HGoPPScwIcCXChpR45aY,1622
+glide_mcp-0.1.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+glide_mcp-0.1.1.dist-info/entry_points.txt,sha256=o7BktmIS8150BSx3cwAOaVL6ntLoEv3mCxyDkcoeUhc,47
+glide_mcp-0.1.1.dist-info/licenses/LICENSE,sha256=bqVuW787bFw2uBL31Xlee7ydibnr_8TkCWlHdi7LXEM,1067
+glide_mcp-0.1.1.dist-info/RECORD,,

glide_mcp-0.1.1.dist-info/WHEEL

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

glide_mcp-0.1.1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+glide_mcp = src.mcp.app:main

glide_mcp-0.1.1.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 SoarAILabs
+
+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.

src/core/LLM/cerebras_inference.py

@@ -0,0 +1,111 @@
+import os
+import asyncio
+from typing import Any, Dict, List, Optional
+from dotenv import load_dotenv
+from cerebras.cloud.sdk import AsyncCerebras
+
+load_dotenv()
+
+# Default model; override per-call via the `model` argument
+DEFAULT_MODEL_ID: str = os.getenv("CEREBRAS_MODEL_ID", "qwen-3-32b")
+
+_async_client: Optional[AsyncCerebras] = None
+
+
+def _get_api_key(explicit_api_key: Optional[str] = None) -> str:
+    api_key = explicit_api_key or os.getenv("CEREBRAS_API_KEY", "")
+    if not api_key:
+        raise RuntimeError(
+            "CEREBRAS_API_KEY is not set. Set it in the environment or pass api_key explicitly."
+        )
+    return api_key
+
+
+def init_cerebras_async_client(api_key: Optional[str] = None) -> AsyncCerebras:
+    """
+    Initialize and cache a global AsyncCerebras client.
+
+    Safe to call multiple times; subsequent calls return the cached instance.
+    """
+    global _async_client
+    if _async_client is None:
+        _async_client = AsyncCerebras(api_key=_get_api_key(api_key))
+    return _async_client
+
+
+def get_cerebras_async_client() -> AsyncCerebras:
+    """Return the cached AsyncCerebras client, initializing it if needed."""
+    return init_cerebras_async_client()
+
+
+async def chat(
+    messages: List[Dict[str, str]],
+    *,
+    model: Optional[str] = None,
+    temperature: Optional[float] = None,
+    max_tokens: Optional[int] = None,
+    api_key: Optional[str] = None,
+    extra_params: Optional[Dict[str, Any]] = None,
+) -> str:
+    """
+    Send a structured chat to Cerebras and return the assistant's message content.
+
+    messages: List of {"role": "user"|"system"|"assistant", "content": str}
+    model: Model name; defaults to DEFAULT_MODEL_ID
+    temperature, max_tokens: Optional generation controls
+    api_key: Optional override for API key (avoids relying on env)
+    extra_params: Additional keyword arguments passed through to the API
+    """
+    client = init_cerebras_async_client(api_key)
+    response = await client.chat.completions.create(
+        messages=messages,
+        model=model or DEFAULT_MODEL_ID,
+        **({"temperature": temperature} if temperature is not None else {}),
+        **({"max_tokens": max_tokens} if max_tokens is not None else {}),
+        **(extra_params or {}),
+    )
+    return response.choices[0].message.content
+
+
+async def complete(
+    prompt: str,
+    *,
+    system: Optional[str] = None,
+    model: Optional[str] = None,
+    temperature: Optional[float] = None,
+    max_tokens: Optional[int] = None,
+    api_key: Optional[str] = None,
+    extra_params: Optional[Dict[str, Any]] = None,
+) -> str:
+    """
+    Convenience wrapper for single-turn prompts. Builds messages from `system` and `prompt`.
+    """
+    messages: List[Dict[str, str]] = []
+    if system:
+        messages.append({"role": "system", "content": system})
+    messages.append({"role": "user", "content": prompt})
+    return await chat(
+        messages,
+        model=model,
+        temperature=temperature,
+        max_tokens=max_tokens,
+        api_key=api_key,
+        extra_params=extra_params,
+    )
+
+
+__all__ = [
+    "init_cerebras_async_client",
+    "get_cerebras_async_client",
+    "chat",
+    "complete",
+    "DEFAULT_MODEL_ID",
+]
+
+
+if __name__ == "__main__":
+    async def _demo() -> None:
+        reply = await complete("Why is fast inference important?")
+        print(reply)
+
+    asyncio.run(_demo())

src/kite_exclusive/commit_splitter/prompts/prompt1.md

@@ -0,0 +1,11 @@
+You are the assistant of Glide by the Interaction Company of California. You are the "execution engine" of Glide, helping split large commits for Glide-MCP, while the MCP client talks to the user. Your job is to execute and accomplish a goal, and you do not have direct access to the user.
+
+Your final output is directed to Glide MCP Client, which handles user conversations and presents your results to the user. Focus on providing Glide with adequate contextual information; you are not responsible for framing responses in a user-friendly way.
+
+If it needs more data from Glide or the user, you should also include it in your final output message.
+
+If you ever need to send a message to the user, you should tell Glide to forward that message to the user.
+
+You should seek to accomplish tasks with as much parallelism as possible. If tasks don't need to be sequential, launch them in parallel. This includes spawning multiple subagents simultaneously for both search operations and MCP integrations when the information could be found in multiple sources.
+
+EXTREMELY IMPORTANT: Never make up information if you can't find it. If you can't find something or you aren't sure about something, relay this to the inbound agent instead of guessing.

src/kite_exclusive/commit_splitter/services/voyage_service.py

@@ -0,0 +1,49 @@
+from helix.embedding.voyageai_client import VoyageAIEmbedder
+from helix import Chunk
+import os
+
+voyage_embedder = VoyageAIEmbedder()
+
+
+def embed_code(code: str, file_path: str = None):
+
+    # For diffs, use token_chunk instead of code_chunk since diffs are text format
+    # and code_chunk has API compatibility issues
+    try:
+        # Try code_chunk first if we have a valid language
+        if file_path:
+            ext = os.path.splitext(file_path)[1].lstrip(".")
+            lang_map = {
+                "py": "python",
+                "js": "javascript",
+                "ts": "typescript",
+                "jsx": "javascript",
+                "tsx": "typescript",
+                "java": "java",
+                "cpp": "cpp",
+                "c": "c",
+                "cs": "csharp",
+                "go": "go",
+                "rs": "rust",
+                "rb": "ruby",
+                "php": "php",
+                "swift": "swift",
+                "kt": "kotlin",
+                "scala": "scala",
+                "sh": "bash",
+                "hx": "python",
+            }
+            language = lang_map.get(ext.lower())
+            if language:
+                code_chunks = Chunk.code_chunk(code, language=language)
+            else:
+                code_chunks = Chunk.token_chunk(code)
+        else:
+            code_chunks = Chunk.token_chunk(code)
+    except Exception:
+        # Fallback to token_chunk if code_chunk fails
+        code_chunks = Chunk.token_chunk(code)
+
+    code_embeddings = voyage_embedder.embed_batch([f"{code_chunks}"])
+
+    return code_embeddings

src/mcp/app.py

@@ -0,0 +1,492 @@
+from src.kite_exclusive.commit_splitter.services.voyage_service import embed_code
+from src.core.LLM.cerebras_inference import complete
+from typing import Any, Dict, List, Tuple
+import subprocess
+import json
+import os
+import asyncio
+from dotenv import load_dotenv
+import helix
+from fastmcp import FastMCP
+load_dotenv()
+
+mcp = FastMCP[Any]("glide")
+
+HELIX_API_ENDPOINT = os.getenv("HELIX_API_ENDPOINT", "")
+
+
+async def find_git_root(start_path: str = None) -> str:
+    """
+    Find the git repository root directory.
+    
+    Args:
+        start_path: Directory to start searching from (defaults to current working directory)
+        
+    Returns:
+        Path to the git repository root, or None if not in a git repository
+    """
+    # First, try to get workspace root from common environment variables
+    # MCP clients like Cursor might set these
+    env_vars = [
+        "MCP_WORKSPACE_ROOT",
+        "CURSOR_WORKSPACE_ROOT", 
+        "WORKSPACE_ROOT",
+        "WORKSPACE_FOLDER",
+        "PROJECT_ROOT"
+    ]
+    
+    for env_var in env_vars:
+        workspace_from_env = os.getenv(env_var)
+        if workspace_from_env and os.path.isdir(workspace_from_env):
+            # Try to find git root starting from this directory
+            start_path = workspace_from_env
+            break
+    
+    if start_path is None:
+        start_path = os.getcwd()
+    
+    # Use git rev-parse --show-toplevel to find the git root
+    # Use asyncio.create_subprocess_exec directly to avoid circular dependency
+    try:
+        process = await asyncio.create_subprocess_exec(
+            "git",
+            "rev-parse",
+            "--show-toplevel",
+            cwd=start_path,
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE,
+            stdin=asyncio.subprocess.DEVNULL,
+        )
+        stdout_data, stderr_data = await process.communicate()
+        
+        if process.returncode == 0:
+            git_root = stdout_data.decode('utf-8').strip()
+            if git_root:
+                return git_root
+    except (FileNotFoundError, OSError):
+        # Git not found or other OS error
+        pass
+    
+    return None
+
+
+# Helper function to run subprocess calls asynchronously to avoid blocking stdio
+async def run_subprocess(args: List[str], **kwargs) -> subprocess.CompletedProcess:
+    """Run subprocess calls asynchronously to avoid blocking stdio transport."""
+    # Use asyncio.create_subprocess_exec instead of subprocess.run to avoid blocking
+    capture_output = kwargs.pop('capture_output', False)
+    text = kwargs.pop('text', False)
+    check = kwargs.pop('check', False)  # Handle check parameter separately
+    
+    # CRITICAL: Set stdin to DEVNULL to prevent subprocess from inheriting 
+    # the MCP stdio stdin, which causes deadlocks
+    stdin = kwargs.pop('stdin', asyncio.subprocess.DEVNULL)
+    
+    # CRITICAL: Always capture stdout/stderr to PIPE to prevent subprocess output
+    # from leaking into the MCP stdio communication channel (which breaks JSON parsing)
+    # In stdio mode, parent's stdout/stderr IS the MCP communication channel, so we must
+    # always capture subprocess output to prevent git messages from breaking JSON protocol
+    stdout = asyncio.subprocess.PIPE
+    stderr = asyncio.subprocess.PIPE
+    # Remove any stdout/stderr from kwargs since we're overriding them
+    kwargs.pop('stdout', None)
+    kwargs.pop('stderr', None)
+    
+    # Only pass valid parameters to asyncio.create_subprocess_exec
+    # Filter out any subprocess.run() specific parameters that aren't valid
+    # Explicitly remove check and other invalid params to prevent errors
+    kwargs.pop('check', None)  # Extra safety: ensure check is removed
+    kwargs.pop('timeout', None)  # timeout handled by asyncio.wait_for elsewhere
+    kwargs.pop('input', None)  # input not supported in async subprocess
+    
+    valid_exec_kwargs = {}
+    allowed_params = {'cwd', 'env', 'start_new_session', 'shell', 'preexec_fn', 
+                      'executable', 'bufsize', 'close_fds', 'pass_fds', 
+                      'restore_signals', 'umask', 'limit', 'creationflags'}
+    for key, value in kwargs.items():
+        if key in allowed_params:
+            valid_exec_kwargs[key] = value
+        # Silently ignore other parameters
+    
+    # Final safety check: ensure check is not in valid_exec_kwargs
+    assert 'check' not in valid_exec_kwargs, "check parameter should not be passed to subprocess"
+    
+    process = await asyncio.create_subprocess_exec(
+        *args,
+        stdin=stdin,
+        stdout=stdout,
+        stderr=stderr,
+        **valid_exec_kwargs
+    )
+    
+    stdout_data, stderr_data = await process.communicate()
+    
+    # Create a CompletedProcess-like object
+    result = subprocess.CompletedProcess(
+        args=args,
+        returncode=process.returncode,
+        stdout=stdout_data.decode('utf-8') if text and stdout_data else stdout_data,
+        stderr=stderr_data.decode('utf-8') if text and stderr_data else stderr_data,
+    )
+    
+    # If check=True, raise CalledProcessError on non-zero return code
+    if check and result.returncode != 0:
+        raise subprocess.CalledProcessError(
+            result.returncode, args, result.stdout, result.stderr
+        )
+    
+    return result
+
+@mcp.tool
+async def draft_pr():
+    instructions = [
+        "step 1: grep for CONTRIBUTING.md or similar documentation in the repository. If unable to find it, look for any contributing guidelines in the repository.",
+        "step 2: if not found, follow best practices for writing a pull request.",
+        "step 3: use the edit file tool to write a new PR_DRAFT.md file for the project.",
+    ]
+    result = "draft pr instructions: \n\n"
+    for i, instruction in enumerate(instructions, 1):
+        result += f"{i}. {instruction}\n\n"
+    return result
+
+
+@mcp.tool(
+    name="split_commit",
+    description="Splits a large unified diff / commit into smaller semantically-grouped commits.",
+)
+async def split_commit(workspace_root: str = None):
+    """
+    Split a large commit into smaller semantic commits.
+    
+    Args:
+        workspace_root: Optional path to the workspace root directory. 
+                        If not provided, will attempt to detect from environment variables or current directory.
+    """
+    try:
+        # Detect the git repository root
+        if workspace_root:
+            # If provided, use it directly
+            detected_root = await find_git_root(workspace_root)
+            if detected_root:
+                workspace_root = detected_root
+            elif not os.path.isdir(workspace_root):
+                return f"error: provided workspace_root '{workspace_root}' does not exist or is not a directory."
+            # If workspace_root is provided but not a git repo, we'll still try to use it
+            # (git commands will fail with a clear error if it's not a git repo)
+        else:
+            # Try to auto-detect
+            workspace_root = await find_git_root()
+            if not workspace_root:
+                cwd = os.getcwd()
+                return (
+                    f"error: could not detect git repository root.\n"
+                    f"Current working directory: {cwd}\n"
+                    f"Please either:\n"
+                    f"  1. Run this tool from within a git repository, or\n"
+                    f"  2. Provide the workspace_root parameter with the path to your git repository root."
+                )
+        
+        # 1) Collect changed files and per-file unified diffs
+        # Check staged, unstaged, and untracked files
+        staged_proc = await run_subprocess(
+            ["git", "diff", "--cached", "--name-only"], 
+            capture_output=True, 
+            text=True,
+            cwd=workspace_root
+        )
+        unstaged_proc = await run_subprocess(
+            ["git", "diff", "--name-only"], 
+            capture_output=True, 
+            text=True,
+            cwd=workspace_root
+        )
+        untracked_proc = await run_subprocess(
+            ["git", "ls-files", "--others", "--exclude-standard"],
+            capture_output=True,
+            text=True,
+            cwd=workspace_root
+        )
+        
+        # Check if git commands failed (might indicate not a git repo)
+        # Note: git commands can return non-zero even in valid repos (e.g., no changes)
+        # Only error if we get explicit "not a git repository" messages
+        error_messages = []
+        if staged_proc.returncode != 0 and staged_proc.stderr:
+            error_messages.append(staged_proc.stderr)
+        if "not a git repository" in " ".join(error_messages).lower():
+            error_msg = f"error: '{workspace_root}' is not a git repository.\n"
+            error_msg += f"Git error: {error_messages[0] if error_messages else 'Unknown error'}\n"
+            error_msg += "Please provide the correct path to your git repository root."
+            return error_msg
+
+        changed_files = set()
+        if staged_proc.returncode == 0:
+            changed_files.update(
+                f.strip() for f in staged_proc.stdout.splitlines() if f.strip()
+            )
+        if unstaged_proc.returncode == 0:
+            changed_files.update(
+                f.strip() for f in unstaged_proc.stdout.splitlines() if f.strip()
+            )
+        if untracked_proc.returncode == 0:
+            changed_files.update(
+                f.strip() for f in untracked_proc.stdout.splitlines() if f.strip()
+            )
+
+        if not changed_files:
+            return "no changes detected (working tree clean)"
+
+        file_to_diff: Dict[str, str] = {}
+        for path in changed_files:
+            # Try staged diff first, then unstaged
+            p = await run_subprocess(
+                ["git", "diff", "--cached", "--", path], 
+                capture_output=True, 
+                text=True,
+                cwd=workspace_root
+            )
+            if p.returncode == 0 and p.stdout.strip():
+                file_to_diff[path] = p.stdout
+            else:
+                p = await run_subprocess(
+                    ["git", "diff", "--", path], 
+                    capture_output=True, 
+                    text=True,
+                    cwd=workspace_root
+                )
+                if p.returncode == 0 and p.stdout.strip():
+                    file_to_diff[path] = p.stdout
+                else:
+                    # For untracked/new files, read the entire file content as the "diff"
+                    # Paths from git are relative to workspace root, so join them
+                    file_path = os.path.join(workspace_root, path) if not os.path.isabs(path) else path
+                    try:
+                        with open(file_path, "r", encoding="utf-8") as f:
+                            content = f.read()
+                            # Format as a new file addition diff
+                            file_to_diff[path] = (
+                                f"diff --git a/{path} b/{path}\nnew file mode 100644\n--- /dev/null\n+++ b/{path}\n@@ -0,0 +1,{len(content.splitlines())} @@\n+{chr(10).join('+'+line for line in content.splitlines())}"
+                            )
+                    except (FileNotFoundError, UnicodeDecodeError):
+                        # File might not exist or not be text
+                        continue
+
+        if not file_to_diff:
+            return "no per-file diffs produced"
+
+        # 2) Embed each file's diff with Voyage (preconfigured in voyage_service)
+        suggestions: List[Tuple[str, str]] = []  # (file_path, suggested_message)
+
+        # Connect Helix client - supports both local and cloud via environment variables
+        use_local = os.getenv("HELIX_LOCAL", "false").lower() == "true"
+        
+        if use_local:
+            db = helix.Client(local=True)
+        else:
+            # Use cloud deployment from helix.toml (production.fly)
+            # Helix SDK automatically reads helix.toml and uses the configured deployment
+            api_endpoint = os.getenv("HELIX_API_ENDPOINT", "")
+            if not HELIX_API_ENDPOINT:
+                return "error: HELIX API ENDPOINT is not set"
+            db = helix.Client(local=False, api_endpoint=api_endpoint)
+
+        for file_path, diff_text in file_to_diff.items():
+            # 2a) Embed with timeout (5 seconds)
+            try:
+                vec_batch = await asyncio.wait_for(
+                    asyncio.to_thread(embed_code, diff_text, file_path=file_path),
+                    timeout=5
+                )
+            except asyncio.TimeoutError:
+                return f"error: embedding timed out for {file_path} (expected to always work)"
+            except Exception as embed_exc:
+                return f"error: embedding failed for {file_path}: {str(embed_exc)} (expected to always work)"
+            
+            if not vec_batch:
+                return f"error: embedding returned empty result for {file_path}"
+            vec = vec_batch[0]
+
+            try:
+                # 3) ANN search for similar diffs; k kept small to keep it snappy
+                # Add timeout to database query (5 seconds)
+                res = await asyncio.wait_for(
+                    asyncio.to_thread(db.query, "getSimilarDiffsByVector", {"vec": vec, "k": 8}),
+                    timeout=5
+                )
+            except asyncio.TimeoutError:
+                # If database query times out, continue without examples
+                res = []
+            except Exception as db_exc:
+                # If database query fails, continue without examples
+                res = []
+            # Result rows include commit_message, summary, file_path
+            examples = []
+            if isinstance(res, list):
+                for row in res[:5]:
+                    if isinstance(row, dict):
+                        ex_msg = row.get("commit_message") or ""
+                        ex_sum = row.get("summary") or ""
+                        ex_path = row.get("file_path") or ""
+                        if ex_msg or ex_sum:
+                            examples.append(
+                                f"file:{ex_path}\nmessage:{ex_msg}\nsummary:{ex_sum}"
+                            )
+
+            example_block = "\n\n".join(examples) if examples else ""
+            
+            # Helper function to detect and reject generic messages
+            def is_generic_message(msg: str) -> bool:
+                """Check if a commit message is too generic."""
+                if not msg:
+                    return True
+                msg_lower = msg.lower().strip()
+                generic_patterns = [
+                    "update ",
+                    "fix bug",
+                    "fix issue",
+                    "refactor code",
+                    "changes",
+                    "wip",
+                    "misc",
+                    "cleanup",
+                    "minor",
+                    "temporary",
+                ]
+                # Check if message starts with generic patterns
+                for pattern in generic_patterns:
+                    if msg_lower.startswith(pattern):
+                        return True
+                # Check if message is just a filename (e.g., "Update app.py")
+                if msg_lower.startswith("update ") and len(msg_lower.split()) <= 3:
+                    return True
+                return False
+            
+            system_prompt = (
+                """You are a senior engineer writing conventional commit messages. Analyze the diff carefully to understand what actually changed.
+
+CRITICAL REQUIREMENTS:
+- Write ONLY a single, concise commit title (under 50 characters preferred)
+- Use conventional commit format: type(scope): description
+- Common types: feat, fix, refactor, docs, style, test, chore, perf, build, ci
+- No issue references, no trailing period
+- Be SPECIFIC about what changed - analyze the actual code changes in the diff
+- Output ONLY the commit message title, nothing else (no explanations, no prefixes, no quotes)
+
+STRICT PROHIBITIONS - NEVER USE THESE PATTERNS:
+- "Update [filename]" (e.g., "Update app.py") - ABSOLUTELY FORBIDDEN
+- "Fix bug" - TOO GENERIC
+- "Refactor code" - TOO GENERIC  
+- "Changes" - TOO GENERIC
+- "WIP" - TOO GENERIC
+- Any message that doesn't describe what actually changed
+
+GUIDELINES:
+- Analyze the actual code changes in the diff to determine the type and description
+- For new features: use "feat:" - describe what capability was added (e.g., "feat(auth): add JWT token validation")
+- For bug fixes: use "fix:" - describe what was broken and fixed (e.g., "fix(api): handle null response in user endpoint")
+- For refactoring: use "refactor:" - describe what was improved without changing behavior (e.g., "refactor(utils): extract common validation logic")
+- For configuration/build: use "chore:" or "build:" - describe what was configured (e.g., "chore(deps): update dependencies")
+- For documentation: use "docs:" - describe what documentation was added/changed (e.g., "docs(api): add endpoint documentation")
+- Include the affected component/file in scope if it adds clarity
+
+EXAMPLES OF GOOD MESSAGES:
+- "feat(auth): add JWT token validation"
+- "fix(api): handle null response in user endpoint"
+- "refactor(utils): extract common validation logic"
+- "chore(deps): update numpy to 2.0.0"
+- "docs(readme): add installation instructions"
+
+EXAMPLES OF BAD MESSAGES (DO NOT USE):
+- "Update app.py" ❌
+- "Fix bug" ❌
+- "Refactor code" ❌
+- "Changes" ❌
+
+Remember: Your output must be SPECIFIC and describe WHAT changed, not generic file operations."""
+            )
+            user_prompt = (
+                "Generate a commit message for this diff. Consider similar past changes if given.\n\n"
+                f"DIFF (truncated if long):\n{diff_text}\n\n"
+                f"SIMILAR EXAMPLES:\n{example_block}\n\n"
+                "Output ONLY the commit message title, nothing else."
+            )
+            
+            # Call Cerebras inference - should always work
+            try:
+                raw_response = await asyncio.wait_for(
+                    complete(user_prompt, system=system_prompt, max_tokens=100),
+                    timeout=30.0
+                )
+            except asyncio.TimeoutError:
+                return f"error: Cerebras inference timed out for {file_path} (expected to always work)"
+            except Exception as llm_exc:
+                return f"error: Cerebras inference failed for {file_path}: {str(llm_exc)} (expected to always work)"
+            
+            if not raw_response:
+                return f"error: Cerebras inference returned empty response for {file_path}"
+            
+            commit_message = raw_response.strip().splitlines()[0].strip()
+            
+            # Remove quotes if present
+            if commit_message.startswith('"') and commit_message.endswith('"'):
+                commit_message = commit_message[1:-1]
+            if commit_message.startswith("'") and commit_message.endswith("'"):
+                commit_message = commit_message[1:-1]
+            
+            # Validate the message is not generic - fail if it is
+            if not commit_message or is_generic_message(commit_message):
+                return (
+                    f"error: Cerebras inference generated generic message '{commit_message}' for {file_path}. "
+                    f"Please improve the system prompt or check the inference output."
+                )
+
+            suggestions.append((file_path, commit_message))
+
+        if not suggestions:
+            return "no commit suggestions could be generated"
+
+        # 4) Commit each file separately with its suggested message
+        for file_path, message in suggestions:
+            try:
+                await run_subprocess(
+                    ["git", "add", "--", file_path], 
+                    check=True,
+                    cwd=workspace_root
+                )
+                await run_subprocess(
+                    ["git", "commit", "-m", message], 
+                    check=True,
+                    cwd=workspace_root
+                )
+            except subprocess.CalledProcessError as e:
+                return (
+                    f"Failed to add or commit '{file_path}' with message '{message}'.\n"
+                    f"Git error: {e}\n"
+                    "Ensure the file exists, is not conflicted, and git is functioning properly."
+                )
+
+        # 5) Return a compact report of what was committed
+        report = {"commits": [{"file": f, "message": m} for f, m in suggestions]}
+        return json.dumps(report, indent=2)
+
+    except Exception as e:
+        return (
+            f"failed to split commit: {str(e)}\n"
+            f"Exception type: {type(e).__name__}\n"
+            "Ensure git is available and HelixDB is reachable on localhost:6969."
+        )
+
+
+@mcp.tool
+async def resolve_conflict():
+    return "resolve conflict ran successfully"
+
+
+def main():
+    """Entry point for the glide-mcp package."""
+    mcp.run(transport="stdio")
+
+
+if __name__ == "__main__":
+    # mcp.run(transport="streamable-http", host="127.0.0.1", port=8000)
+    main()