glide-mcp 0.1.6__tar.gz

glide_mcp-0.1.6/.cursor/commands/deslop.md

@@ -0,0 +1,11 @@
+# Remove AI code slop
+
+remove all AI generated slop introduced in this branch.
+
+This includes:
+- Extra comments that a human wouldn't add or is inconsistent with the rest of the file
+- Extra defensive checks or try/catch blocks that are abnormal for that area of the codebase (especially if called by trusted / validated codepaths)
+- Casts to any to get around type issues
+- Any other style that is inconsistent with the file
+
+Report at the end with only a 1-3 sentence summary of what you changed

glide_mcp-0.1.6/.env.example

@@ -0,0 +1,4 @@
+VOYAGEAI_API_KEY=pa-...
+CEREBRAS_API_KEY=csk...
+HELIX_LOCAL=False # or True 
+HELIX_API_ENDPOINT=https://your-helix-deployment.dev

glide_mcp-0.1.6/.gitignore

@@ -0,0 +1,9 @@
+.helix/
+target/
+*.log
+
+.env
+
+__pycache__/
+
+glide.egg-info/

glide_mcp-0.1.6/.python-version

@@ -0,0 +1 @@
+3.13

glide_mcp-0.1.6/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.

glide_mcp-0.1.6/PKG-INFO

@@ -0,0 +1,67 @@
+Metadata-Version: 2.4
+Name: glide-mcp
+Version: 0.1.6
+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-mcp&config=eyJlbnYiOnsiVk9ZQUdFQUlfQVBJX0tFWSI6IiIsIkhFTElYX0FQSV9FTkRQT0lOVCI6IiIsIkNFUkVCUkFTX0FQSV9LRVkiOiIiLCJDRVJFQlJBU19NT0RFTF9JRCI6InF3ZW4tMy0zMmIiLCJIRUxJWF9MT0NBTCI6IiJ9LCJjb21tYW5kIjoidXZ4IC0tZnJvbSBnbGlkZS1tY3AgZ2xpZGUifQ%3D%3D)
+
+**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.6/README.md

@@ -0,0 +1,51 @@
+## 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-mcp&config=eyJlbnYiOnsiVk9ZQUdFQUlfQVBJX0tFWSI6IiIsIkhFTElYX0FQSV9FTkRQT0lOVCI6IiIsIkNFUkVCUkFTX0FQSV9LRVkiOiIiLCJDRVJFQlJBU19NT0RFTF9JRCI6InF3ZW4tMy0zMmIiLCJIRUxJWF9MT0NBTCI6IiJ9LCJjb21tYW5kIjoidXZ4IC0tZnJvbSBnbGlkZS1tY3AgZ2xpZGUifQ%3D%3D)
+
+**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.6/db/queries.hx

@@ -0,0 +1,131 @@
+// Minimal queries for ingesting Git graph data and retrieving semantic diffs.
+// Commit messages are generated in the app using retrieved diff summaries.
+
+// Ingestion helpers
+
+// createRepository: creates the root repository node; needed to scope all data.
+QUERY createRepository(repo_id: String, name: String) =>
+    repo <- AddN<Repository>({
+        repo_id: repo_id,
+        name: name
+    })
+    RETURN repo
+
+// createBranch: creates a branch and links it to its repo
+QUERY createBranch(repo_id: String, branch_id: String, name: String) =>
+    repo <- N<Repository>({repo_id: repo_id})
+    branch <- AddN<Branch>({
+        branch_id: branch_id,
+        name: name
+    })
+    AddE<HAS_BRANCH>()::From(repo)::To(branch)
+    RETURN branch
+
+// createCommit: creates a commit on a branch
+QUERY createCommit(
+    branch_id: String,
+    commit_id: String,
+    short_id: String,
+    author: String,
+    committed_at: Date,
+    is_merge: Boolean
+) =>
+    branch <- N<Branch>({branch_id: branch_id})
+    commit <- AddN<Commit>({
+        commit_id: commit_id,
+        short_id: short_id,
+        author: author,
+        committed_at: committed_at,
+        is_merge: is_merge
+    })
+    AddE<HAS_COMMIT>()::From(branch)::To(commit)
+    RETURN commit
+
+
+// LinkParentCommit: records DAG parentage
+QUERY linkParentCommit(child_commit_id: String, parent_commit_id: String) =>
+    child <- N<Commit>({commit_id: child_commit_id})
+    parent <- N<Commit>({commit_id: parent_commit_id})
+    AddE<PARENT>()::From(child)::To(parent)
+    RETURN "OK"
+
+
+// createFile: creates a file node; enables path-scoped queries and file-level analytics.
+QUERY createFile(file_id: String, path: String, language: String) =>
+    file <- AddN<File>({
+        file_id: file_id,
+        path: path,
+        language: language
+    })
+    RETURN file
+
+
+// createDiff: attaches a diff with a precomputed Voyage vector
+QUERY createDiff(
+    commit_id: String,
+    file_id: String,
+    diff_id: String,
+    kind: String,
+    additions: I64,
+    deletions: I64,
+    summary: String,
+    vec: [F64]
+) =>
+    commit <- N<Commit>({commit_id: commit_id})
+    file <- N<File>({file_id: file_id})
+    diff <- AddN<Diff>({
+        diff_id: diff_id,
+        kind: kind,
+        additions: additions,
+        deletions: deletions,
+        summary: summary
+    })
+    embedding <- AddV<DiffEmbedding>(vec)
+    AddE<HAS_DIFF>()::From(commit)::To(diff)
+    AddE<AFFECTS_FILE>()::From(diff)::To(file)
+    AddE<HAS_EMBEDDING>()::From(diff)::To(embedding)
+    RETURN diff
+
+
+
+
+// Search & retrieval
+
+// getSimilarDiffsByVector: ANN over diffs using vectors
+QUERY getSimilarDiffsByVector(vec: [F64], k: I64) =>
+    embeddings <- SearchV<DiffEmbedding>(vec, k)
+    results <- embeddings::In<HAS_EMBEDDING>
+    RETURN results::{
+        diff_id: diff_id,
+        kind: kind,
+        additions: additions,
+        deletions: deletions,
+        summary: summary,
+        commit_id: _::In<HAS_DIFF>::{commit_id},
+        commit_message: _::In<HAS_DIFF>::{message},
+        file_path: _::Out<AFFECTS_FILE>::{path}
+    }
+
+
+// getDiffIdsForRepo: collects diff IDs under a repo
+QUERY getDiffIdsForRepo(repo_id: String) =>
+    diffs <- N<Repository>({repo_id: repo_id})::Out<HAS_BRANCH>::Out<HAS_COMMIT>::Out<HAS_DIFF>
+    RETURN diffs::{ diff_id: diff_id }
+
+
+// getDiffIdsForBranch: collects diff IDs under a branch
+QUERY getDiffIdsForBranch(branch_id: String) =>
+    diffs <- N<Branch>({branch_id: branch_id})::Out<HAS_COMMIT>::Out<HAS_DIFF>
+    RETURN diffs::{ diff_id: diff_id }
+
+// GetCommitDiffSummaries: returns per-diff summaries and paths for a commit
+QUERY getCommitDiffSummaries(commit_id: String) =>
+    diffs <- N<Commit>({commit_id: commit_id})::Out<HAS_DIFF>
+    RETURN diffs::{
+        diff_id: diff_id,
+        kind: kind,
+        additions: additions,
+        deletions: deletions,
+        summary: summary,
+        file_path: _::Out<AFFECTS_FILE>::{path}
+    }

glide_mcp-0.1.6/db/schema.hx

@@ -0,0 +1,77 @@
+// Nodes
+N::Repository {
+  INDEX repo_id: String,
+  INDEX name: String,
+  created_at: Date DEFAULT NOW
+}
+
+N::Branch {
+  INDEX branch_id: String,
+  name: String,
+  created_at: Date DEFAULT NOW
+}
+
+N::Commit {
+  INDEX commit_id: String,
+  short_id: String,
+  author: String,
+  message: String,
+  committed_at: Date,
+  is_merge: Boolean DEFAULT false
+}
+
+N::File {
+  INDEX file_id: String,
+  path: String,
+  language: String
+}
+
+N::Diff {
+  INDEX diff_id: String,
+  kind: String,
+  additions: I64,
+  deletions: I64,
+  summary: String
+}
+
+// Vector type for embeddings
+V::DiffEmbedding {
+  vector: [F64]
+}
+
+// Edges
+E::HAS_BRANCH {
+  From: Repository,
+  To: Branch,
+  Properties: {}
+}
+
+E::HAS_COMMIT {
+  From: Branch,
+  To: Commit,
+  Properties: {}
+}
+
+E::PARENT {
+  From: Commit,
+  To: Commit,
+  Properties: {}
+}
+
+E::HAS_DIFF {
+  From: Commit,
+  To: Diff,
+  Properties: {}
+}
+
+E::AFFECTS_FILE {
+  From: Diff,
+  To: File,
+  Properties: {}
+}
+
+E::HAS_EMBEDDING {
+  From: Diff,
+  To: DiffEmbedding,
+  Properties: {}
+}

glide_mcp-0.1.6/helix.toml

@@ -0,0 +1,18 @@
+[project]
+name = "glide"
+queries = "./db/"
+
+[local.dev]
+port = 6969
+build_mode = "dev"
+
+[local.glide]
+build_mode = "dev"
+
+[cloud.production.fly]
+build_mode = "debug"
+vm_size = "shared-cpu-4x"
+volume = "helix_glide_production_data:/data"
+volume_initial_size = 20
+private = false
+auth_type = "Cli"

glide_mcp-0.1.6/pyproject.toml

@@ -0,0 +1,32 @@
+[project]
+name = "glide-mcp"
+version = "0.1.6"
+description = "mcp server that tries to save you from git troubles"
+readme = "README.md"
+requires-python = ">=3.13"
+dependencies = [
+    "black>=25.9.0",
+    "cerebras-cloud-sdk>=1.56.1",
+    "fastmcp>=2.12.5",
+    "helix-py>=0.2.30",
+    "numpy>=2.3.4",
+    "pytest>=8.4.2",
+    "pytest-asyncio>=1.2.0",
+    "python-dotenv>=1.1.1",
+]
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src"]
+
+[tool.uv]
+package = true
+
+[tool.uv.workspace]
+members = []
+
+[project.scripts]
+glide = "src.mcp.app:main"

glide_mcp-0.1.6/requirements.txt

@@ -0,0 +1,9 @@
+# Core dependencies - only what your code actually imports
+black>=25.9.0
+cerebras-cloud-sdk>=1.56.1
+fastmcp>=2.12.5
+helix-py>=0.2.30
+numpy>=2.3.4
+pytest>=8.4.2
+pytest-asyncio>=1.2.0
+python-dotenv>=1.1.1

glide_mcp-0.1.6/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-coder-480b")
+
+_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())

glide_mcp-0.1.6/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.

glide_mcp-0.1.6/src/kite_exclusive/commit_splitter/services/voyage_service.py

@@ -0,0 +1,59 @@
+from helix.embedding.voyageai_client import VoyageAIEmbedder
+from helix import Chunk
+import os
+
+# Lazy-loaded embedder - only created when needed
+_voyage_embedder = None
+
+
+def _get_embedder():
+    """Get or create the voyage embedder instance (lazy initialization)."""
+    global _voyage_embedder
+    if _voyage_embedder is None:
+        _voyage_embedder = VoyageAIEmbedder()
+    return _voyage_embedder
+
+
+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)
+
+    voyage_embedder = _get_embedder()
+    code_embeddings = voyage_embedder.embed_batch([f"{code_chunks}"])
+
+    return code_embeddings