mcp-code-indexer 3.0.3__py3-none-any.whl → 3.1.1__py3-none-any.whl

mcp_code_indexer/database/database.py

@@ -509,14 +509,12 @@ class DatabaseManager:
         async with self.get_write_connection_with_retry("create_project") as db:
             await db.execute(
                 """
-                INSERT INTO projects (id, name, remote_origin, upstream_origin, aliases, created, last_accessed)
-                VALUES (?, ?, ?, ?, ?, ?, ?)
+                INSERT INTO projects (id, name, aliases, created, last_accessed)
+                VALUES (?, ?, ?, ?, ?)
                 """,
                 (
                     project.id,
                     project.name,
-                    project.remote_origin,
-                    project.upstream_origin,
                     json.dumps(project.aliases),
                     project.created,
                     project.last_accessed
@@ -538,44 +536,15 @@ class DatabaseManager:
                 return Project(
                     id=row['id'],
                     name=row['name'],
-                    remote_origin=row['remote_origin'],
-                    upstream_origin=row['upstream_origin'],
                     aliases=json.loads(row['aliases']),
                     created=datetime.fromisoformat(row['created']),
                     last_accessed=datetime.fromisoformat(row['last_accessed'])
                 )
             return None
     
-    async def find_project_by_origin(self, origin_url: str) -> Optional[Project]:
-        """Find project by remote or upstream origin URL."""
-        async with self.get_connection() as db:
-            cursor = await db.execute(
-                """
-                SELECT * FROM projects 
-                WHERE remote_origin = ? OR upstream_origin = ?
-                LIMIT 1
-                """,
-                (origin_url, origin_url)
-            )
-            row = await cursor.fetchone()
-            
-            if row:
-                return Project(
-                    id=row['id'],
-                    name=row['name'],
-                    remote_origin=row['remote_origin'],
-                    upstream_origin=row['upstream_origin'],
-                    aliases=json.loads(row['aliases']),
-                    created=datetime.fromisoformat(row['created']),
-                    last_accessed=datetime.fromisoformat(row['last_accessed'])
-                )
-            return None
-
     async def find_matching_project(
         self, 
         project_name: str, 
-        remote_origin: Optional[str] = None,
-        upstream_origin: Optional[str] = None,
         folder_path: Optional[str] = None
     ) -> Optional[Project]:
         """
@@ -583,8 +552,6 @@ class DatabaseManager:
         
         Args:
             project_name: Name of the project
-            remote_origin: Remote origin URL
-            upstream_origin: Upstream origin URL  
             folder_path: Project folder path
             
         Returns:
@@ -602,48 +569,27 @@ class DatabaseManager:
             
             # Check name match (case-insensitive)
             if project.name.lower() == normalized_name:
-                score += 1
+                score += 2  # Name match is primary identifier
                 match_factors.append("name")
             
-            # Check remote origin match
-            if remote_origin and project.remote_origin == remote_origin:
-                score += 1
-                match_factors.append("remote_origin")
-            
-            # Check upstream origin match
-            if upstream_origin and project.upstream_origin == upstream_origin:
-                score += 1
-                match_factors.append("upstream_origin")
-            
             # Check folder path in aliases
             if folder_path and folder_path in project.aliases:
                 score += 1
                 match_factors.append("folder_path")
             
-            # Enhanced matching: If name matches and no remote origins are provided,
-            # consider it a strong match to prevent duplicates
-            if (score == 1 and "name" in match_factors and 
-                not remote_origin and not project.remote_origin and
-                not upstream_origin and not project.upstream_origin):
-                logger.info(f"Name-only match with no remotes for project {project.name} - treating as strong match")
-                score = 2  # Boost score to strong match level
-                match_factors.append("no_remotes_boost")
-            
-            # If we have 2+ matches, this is a strong candidate
+            # If we have a name match, it's a strong candidate
             if score >= 2:
                 if score > best_score:
                     best_score = score
                     best_match = project
-                    logger.info(f"Strong match for project {project.name} (score: {score}, factors: {match_factors})")
+                    logger.info(f"Match for project {project.name} (score: {score}, factors: {match_factors})")
         
         return best_match
 
     async def get_or_create_project(
         self,
         project_name: str,
-        folder_path: str,
-        remote_origin: Optional[str] = None,
-        upstream_origin: Optional[str] = None
+        folder_path: str
     ) -> Project:
         """
         Get or create a project using intelligent matching.
@@ -651,15 +597,13 @@ class DatabaseManager:
         Args:
             project_name: Name of the project
             folder_path: Project folder path
-            remote_origin: Remote origin URL
-            upstream_origin: Upstream origin URL
             
         Returns:
             Existing or newly created project
         """
         # Try to find existing project
         project = await self.find_matching_project(
-            project_name, remote_origin, upstream_origin, folder_path
+            project_name, folder_path
         )
         
         if project:
@@ -680,8 +624,6 @@ class DatabaseManager:
         new_project = Project(
             id=str(uuid.uuid4()),
             name=project_name,
-            remote_origin=remote_origin,
-            upstream_origin=upstream_origin,
             aliases=[folder_path],
             created=datetime.utcnow(),
             last_accessed=datetime.utcnow()
@@ -706,13 +648,11 @@ class DatabaseManager:
             await db.execute(
                 """
                 UPDATE projects 
-                SET name = ?, remote_origin = ?, upstream_origin = ?, aliases = ?, last_accessed = ?
+                SET name = ?, aliases = ?, last_accessed = ?
                 WHERE id = ?
                 """,
                 (
                     project.name,
-                    project.remote_origin,
-                    project.upstream_origin,
                     json.dumps(project.aliases),
                     project.last_accessed,
                     project.id
@@ -725,21 +665,19 @@ class DatabaseManager:
         """Get all projects in the database."""
         async with self.get_connection() as db:
             cursor = await db.execute(
-                "SELECT id, name, remote_origin, upstream_origin, aliases, created, last_accessed FROM projects"
+                "SELECT id, name, aliases, created, last_accessed FROM projects"
             )
             rows = await cursor.fetchall()
             
             projects = []
             for row in rows:
-                aliases = json.loads(row[4]) if row[4] else []
+                aliases = json.loads(row[2]) if row[2] else []
                 project = Project(
                     id=row[0],
                     name=row[1],
-                    remote_origin=row[2],
-                    upstream_origin=row[3],
                     aliases=aliases,
-                    created=row[5],
-                    last_accessed=row[6]
+                    created=row[3],
+                    last_accessed=row[4]
                 )
                 projects.append(project)
             
@@ -1031,22 +969,7 @@ class DatabaseManager:
         
         return len(inherited_descriptions)
     
-    async def check_upstream_inheritance_needed(self, project: Project) -> bool:
-        """
-        Check if a project needs upstream inheritance.
-        
-        Args:
-            project: Project to check
-            
-        Returns:
-            True if project has upstream but no descriptions yet
-        """
-        if not project.upstream_origin:
-            return False
-        
-        # Check if project has any descriptions
-        file_count = await self.get_file_count(project.id, "main")
-        return file_count == 0
+
     
     # Project Overview operations
     

mcp_code_indexer/database/models.py

@@ -15,13 +15,11 @@ class Project(BaseModel):
     """
     Represents a tracked project/repository.
     
-    Projects are identified by a combination of git remotes and local paths,
-    allowing tracking across forks, renames, and different local copies.
+    Projects are identified by project name and folder paths,
+    allowing tracking across different local copies without git coupling.
     """
     id: str = Field(..., description="Generated unique identifier")
     name: str = Field(..., description="User-provided project name")
-    remote_origin: Optional[str] = Field(None, description="Git remote origin URL")
-    upstream_origin: Optional[str] = Field(None, description="Upstream repository URL for forks")
     aliases: List[str] = Field(default_factory=list, description="Alternative identifiers")
     created: datetime = Field(default_factory=datetime.utcnow, description="Creation timestamp")
     last_accessed: datetime = Field(default_factory=datetime.utcnow, description="Last access timestamp")

mcp_code_indexer/git_hook_handler.py

@@ -14,7 +14,7 @@ import subprocess
 import tempfile
 from pathlib import Path
 from typing import Dict, List, Optional, Tuple, Any
-from urllib.parse import urlparse
+
 
 import aiohttp
 from tenacity import retry, wait_exponential, stop_after_attempt, retry_if_exception_type
@@ -295,50 +295,18 @@ Return ONLY a JSON object:
             # Get current working directory as project root
             project_root = Path.cwd()
             
-            # Get git remote info
-            remote_result = await self._run_git_command(["remote", "get-url", "origin"])
-            remote_origin = remote_result.strip() if remote_result else None
-            
-            # Try to get upstream origin
-            upstream_origin = None
-            try:
-                upstream_result = await self._run_git_command(["remote", "get-url", "upstream"])
-                upstream_origin = upstream_result.strip() if upstream_result else None
-            except subprocess.CalledProcessError:
-                pass  # No upstream remote
-            
-            # Extract project name from remote URL or use directory name
-            project_name = self._extract_project_name(remote_origin, project_root)
+            # Use directory name as project name
+            project_name = project_root.name
             
             return {
                 "projectName": project_name,
-                "folderPath": str(project_root),
-                "remoteOrigin": remote_origin,
-                "upstreamOrigin": upstream_origin
+                "folderPath": str(project_root)
             }
             
         except Exception as e:
             raise GitHookError(f"Failed to identify project from git: {e}")
     
-    def _extract_project_name(self, remote_origin: Optional[str], project_root: Path) -> str:
-        """Extract project name from remote URL or directory name."""
-        if remote_origin:
-            # Parse GitHub/GitLab URL
-            if remote_origin.startswith("git@"):
-                # SSH format: git@github.com:user/repo.git
-                parts = remote_origin.split(":")
-                if len(parts) >= 2:
-                    repo_path = parts[-1].replace(".git", "")
-                    return repo_path.split("/")[-1]
-            else:
-                # HTTPS format
-                parsed = urlparse(remote_origin)
-                if parsed.path:
-                    repo_path = parsed.path.strip("/").replace(".git", "")
-                    return repo_path.split("/")[-1]
-        
-        # Fallback to directory name
-        return project_root.name
+
     
     async def _get_git_diff(self) -> str:
         """

mcp_code_indexer/logging_config.py

@@ -198,7 +198,7 @@ def _setup_component_loggers_for_command(
         "mcp_code_indexer.token_counter",
         "mcp_code_indexer.file_scanner",
         "mcp_code_indexer.error_handler",
-        "mcp_code_indexer.merge_handler"
+
     ]
     
     for component_logger_name in component_loggers:

mcp_code_indexer/main.py

@@ -129,8 +129,6 @@ async def handle_getprojects(args: argparse.Namespace) -> None:
         for project in projects:
             print(f"ID: {project.id}")
             print(f"Name: {project.name}")
-            print(f"Remote Origin: {project.remote_origin or 'N/A'}")
-            print(f"Upstream Origin: {project.upstream_origin or 'N/A'}")
             
             # Get branch information
             try:
@@ -293,7 +291,6 @@ async def handle_runcommand(args: argparse.Namespace) -> None:
             "get_codebase_overview": server._handle_get_condensed_overview,
             "update_codebase_overview": server._handle_update_codebase_overview,
             "get_word_frequency": server._handle_get_word_frequency,
-            "merge_branch_descriptions": server._handle_merge_branch_descriptions,
             "search_codebase_overview": server._handle_search_codebase_overview,
         }
         
@@ -706,12 +703,6 @@ def generate_project_markdown(project, branch, overview, files, logger):
     markdown_lines.append("")
     
     # Project metadata
-    if project.remote_origin:
-        markdown_lines.append(f"**Repository:** {project.remote_origin}")
-        markdown_lines.append("")
-    if project.upstream_origin:
-        markdown_lines.append(f"**Upstream:** {project.upstream_origin}")
-        markdown_lines.append("")
     markdown_lines.append(f"**Branch:** {branch}")
     markdown_lines.append("")
     

mcp_code_indexer/migrations/005_remove_git_remotes.sql

@@ -0,0 +1,41 @@
+-- Migration 005: Remove git remote dependencies from projects table
+-- This migration removes remote_origin and upstream_origin columns and their indexes
+-- Project identification now relies solely on project name and folder paths
+
+-- Ensure WAL mode is enabled for safe migrations
+PRAGMA journal_mode=WAL;
+
+-- Temporarily disable foreign key constraints for migration
+PRAGMA foreign_keys=OFF;
+
+-- Start transaction for atomic migration
+BEGIN TRANSACTION;
+
+-- Create new projects table without git remote columns
+CREATE TABLE projects_new (
+    id TEXT PRIMARY KEY,
+    name TEXT NOT NULL,
+    aliases TEXT DEFAULT '[]', -- JSON array of aliases
+    created DATETIME DEFAULT CURRENT_TIMESTAMP,
+    last_accessed DATETIME DEFAULT CURRENT_TIMESTAMP
+);
+
+-- Create indexes for the new table (without remote indexes)
+CREATE INDEX idx_projects_new_name ON projects_new(name);
+
+-- Migrate data from old table (dropping remote_origin and upstream_origin)
+INSERT INTO projects_new (id, name, aliases, created, last_accessed)
+SELECT id, name, aliases, created, last_accessed
+FROM projects;
+
+-- Drop old table
+DROP TABLE projects;
+
+-- Rename new table to original name
+ALTER TABLE projects_new RENAME TO projects;
+
+-- Re-enable foreign key constraints
+PRAGMA foreign_keys=ON;
+
+-- Commit the migration
+COMMIT;

mcp_code_indexer/server/mcp_server.py

@@ -519,17 +519,13 @@ src/
         """
         Get or create a project ID using intelligent matching.
         
-        Matches projects based on 2+ out of 4 identification factors:
+        Matches projects based on identification factors:
         1. Project name (normalized, case-insensitive)
-        2. Remote origin URL
-        3. Upstream origin URL  
-        4. Any folder path in aliases
+        2. Folder path in aliases
         
-        If only 1 factor matches, uses file similarity to determine if it's the same project.
+        Projects are now identified primarily by name without git coupling.
         """
         project_name = arguments["projectName"]
-        remote_origin = arguments.get("remoteOrigin")
-        upstream_origin = arguments.get("upstreamOrigin")
         folder_path = arguments["folderPath"]
 
         
@@ -538,55 +534,33 @@ src/
         
         # Find potential project matches
         project = await self._find_matching_project(
-            normalized_name, remote_origin, upstream_origin, folder_path
+            normalized_name, folder_path
         )
         if project:
             # Update project metadata and aliases
-            await self._update_existing_project(project, normalized_name, remote_origin, upstream_origin, folder_path)
-            
-            # Check if upstream inheritance is needed
-            if upstream_origin and await self.db_manager.check_upstream_inheritance_needed(project):
-                try:
-                    inherited_count = await self.db_manager.inherit_from_upstream(project)
-                    if inherited_count > 0:
-                        logger.info(f"Auto-inherited {inherited_count} descriptions from upstream for {normalized_name}")
-                except Exception as e:
-                    logger.warning(f"Failed to inherit from upstream: {e}")
+            await self._update_existing_project(project, normalized_name, folder_path)
         else:
             # Create new project with UUID
             project_id = str(uuid.uuid4())
             project = Project(
                 id=project_id,
                 name=normalized_name,
-                remote_origin=remote_origin,
-                upstream_origin=upstream_origin,
                 aliases=[folder_path],
                 created=datetime.utcnow(),
                 last_accessed=datetime.utcnow()
             )
             await self.db_manager.create_project(project)
             logger.info(f"Created new project: {normalized_name} ({project_id})")
-            
-            # Auto-inherit from upstream if needed
-            if upstream_origin:
-                try:
-                    inherited_count = await self.db_manager.inherit_from_upstream(project)
-                    if inherited_count > 0:
-                        logger.info(f"Auto-inherited {inherited_count} descriptions from upstream for {normalized_name}")
-                except Exception as e:
-                    logger.warning(f"Failed to inherit from upstream: {e}")
         
         return project.id
     
     async def _find_matching_project(
         self, 
         normalized_name: str, 
-        remote_origin: Optional[str], 
-        upstream_origin: Optional[str], 
         folder_path: str
     ) -> Optional[Project]:
         """
-        Find a matching project using intelligent 2-out-of-4 matching logic.
+        Find a matching project using name and folder path matching.
         
         Returns the best matching project or None if no sufficient match is found.
         """
@@ -599,45 +573,26 @@ src/
             score = 0
             match_factors = []
             
-            # Factor 1: Project name match
+            # Factor 1: Project name match (primary identifier)
             if project.name.lower() == normalized_name:
-                score += 1
+                score += 2  # Higher weight for name match
                 match_factors.append("name")
             
-            # Factor 2: Remote origin match
-            if remote_origin and project.remote_origin == remote_origin:
-                score += 1
-                match_factors.append("remote_origin")
-                
-            # Factor 3: Upstream origin match  
-            if upstream_origin and project.upstream_origin == upstream_origin:
-                score += 1
-                match_factors.append("upstream_origin")
-                
-            # Factor 4: Folder path in aliases
+            # Factor 2: Folder path in aliases
             project_aliases = json.loads(project.aliases) if isinstance(project.aliases, str) else project.aliases
             if folder_path in project_aliases:
                 score += 1
                 match_factors.append("folder_path")
             
-            # Enhanced matching: If name matches and no remote origins are provided,
-            # consider it a strong match to prevent duplicates
-            if (score == 1 and "name" in match_factors and 
-                not remote_origin and not project.remote_origin and
-                not upstream_origin and not project.upstream_origin):
-                logger.info(f"Name-only match with no remotes for project {project.name} - treating as strong match to prevent duplicates")
-                score = 2  # Boost score to strong match level
-                match_factors.append("no_remotes_boost")
-            
-            # If we have 2+ matches, this is a strong candidate
+            # If we have a name match, it's a strong candidate
             if score >= 2:
                 if score > best_score:
                     best_score = score
                     best_match = project
-                    logger.info(f"Strong match for project {project.name} (score: {score}, factors: {match_factors})")
+                    logger.info(f"Match for project {project.name} (score: {score}, factors: {match_factors})")
             
-            # If only 1 match, check file similarity for potential matches
-            elif score == 1:
+            # If only name matches, check file similarity for potential matches
+            elif score == 1 and "name" in match_factors:
                 if await self._check_file_similarity(project, folder_path):
                     logger.info(f"File similarity match for project {project.name} (factor: {match_factors[0]})")
                     if score > best_score:
@@ -685,8 +640,6 @@ src/
         self, 
         project: Project, 
         normalized_name: str,
-        remote_origin: Optional[str], 
-        upstream_origin: Optional[str], 
         folder_path: str
     ) -> None:
         """Update an existing project with new metadata and folder alias."""
@@ -699,15 +652,6 @@ src/
         if project.name != normalized_name:
             project.name = normalized_name
             should_update = True
-            
-        # Update remote/upstream origins if provided and different
-        if remote_origin and project.remote_origin != remote_origin:
-            project.remote_origin = remote_origin
-            should_update = True
-            
-        if upstream_origin and project.upstream_origin != upstream_origin:
-            project.upstream_origin = upstream_origin
-            should_update = True
         
         # Add folder path to aliases if not already present
         project_aliases = json.loads(project.aliases) if isinstance(project.aliases, str) else project.aliases

{mcp_code_indexer-3.0.3.dist-info → mcp_code_indexer-3.1.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mcp-code-indexer
-Version: 3.0.3
+Version: 3.1.1
 Summary: MCP server that tracks file descriptions across codebases, enabling AI agents to efficiently navigate and understand code through searchable summaries and token-aware overviews.
 Author: MCP Code Indexer Contributors
 Maintainer: MCP Code Indexer Contributors
@@ -59,8 +59,8 @@ Dynamic: requires-python
 
 # MCP Code Indexer 🚀
 
-[![PyPI version](https://badge.fury.io/py/mcp-code-indexer.svg?21)](https://badge.fury.io/py/mcp-code-indexer)
-[![Python](https://img.shields.io/pypi/pyversions/mcp-code-indexer.svg?21)](https://pypi.org/project/mcp-code-indexer/)
+[![PyPI version](https://badge.fury.io/py/mcp-code-indexer.svg?22)](https://badge.fury.io/py/mcp-code-indexer)
+[![Python](https://img.shields.io/pypi/pyversions/mcp-code-indexer.svg?22)](https://pypi.org/project/mcp-code-indexer/)
 [![License](https://img.shields.io/badge/License-MIT-blue.svg)](https://opensource.org/licenses/MIT)
 
 A production-ready **Model Context Protocol (MCP) server** that revolutionizes how AI agents navigate and understand codebases. Built for high-concurrency environments with advanced database resilience, the server provides instant access to intelligent descriptions, semantic search, and context-aware recommendations while maintaining 800+ writes/sec throughput.
@@ -72,8 +72,7 @@ The MCP Code Indexer solves a critical problem for AI agents working with large
 - **Query file purposes** instantly with natural language descriptions
 - **Search across codebases** using full-text search
 - **Get intelligent recommendations** based on codebase size (overview vs search)
-- **Merge branch descriptions** with conflict resolution
-- **Inherit descriptions** from upstream repositories automatically
+- **Generate condensed overviews** for project understanding
 
 Perfect for AI-powered code review, refactoring tools, documentation generation, and codebase analysis workflows.
 
@@ -243,7 +242,6 @@ The server provides **12 powerful MCP tools** for intelligent codebase managemen
 ### 🔍 For Advanced Users: Search & Discovery
 - **`get_all_descriptions`** - Complete hierarchical project structure
 - **`get_word_frequency`** - Technical vocabulary analysis with stop-word filtering
-- **`merge_branch_descriptions`** - Two-phase merge with conflict resolution
 - **`update_codebase_overview`** - Create comprehensive codebase documentation
 
 ### 🏥 For System Monitoring: Health & Performance
@@ -253,7 +251,7 @@ The server provides **12 powerful MCP tools** for intelligent codebase managemen
 
 ## 🔗 Git Hook Integration
 
-Keep your codebase documentation automatically synchronized with automated analysis on every commit, rebase, or merge:
+Keep your codebase documentation automatically synchronized with automated analysis on every commit:
 
 ```bash
 # Analyze current staged changes
@@ -396,8 +394,7 @@ async def analyze_codebase(project_path):
     # Check if codebase is large
     size_info = await mcp_client.call_tool("check_codebase_size", {
         "projectName": "my-project",
-        "folderPath": project_path,
-        "branch": "main"
+        "folderPath": project_path
     })
     
     if size_info["isLarge"]:
@@ -405,15 +402,13 @@ async def analyze_codebase(project_path):
         results = await mcp_client.call_tool("search_descriptions", {
             "projectName": "my-project", 
             "folderPath": project_path,
-            "branch": "main",
             "query": "authentication logic"
         })
     else:
         # Get full overview for smaller projects
         overview = await mcp_client.call_tool("get_codebase_overview", {
             "projectName": "my-project",
-            "folderPath": project_path, 
-            "branch": "main"
+            "folderPath": project_path
         })
 ```
 
@@ -432,8 +427,7 @@ async def analyze_codebase(project_path):
         # Find files without descriptions
         missing = await client.call_tool('find_missing_descriptions', {
             'projectName': '${{ github.repository }}',
-            'folderPath': '.',
-            'branch': '${{ github.ref_name }}'
+            'folderPath': '.'
         })
         
         # Process with AI and update...
@@ -502,14 +496,14 @@ mcp-code-indexer --githook [OPTIONS]
 
 ### Utility Commands
 ```bash
-# List all projects and branches
+# List all projects
 mcp-code-indexer --getprojects
 
 # Execute MCP tool directly
 mcp-code-indexer --runcommand '{"method": "tools/call", "params": {...}}'
 
 # Export descriptions for a project
-mcp-code-indexer --dumpdescriptions PROJECT_ID [BRANCH]
+mcp-code-indexer --dumpdescriptions PROJECT_ID
 ```
 
 ## 🛡️ Security Features

{mcp_code_indexer-3.0.3.dist-info → mcp_code_indexer-3.1.1.dist-info}/RECORD

@@ -6,18 +6,17 @@ mcp_code_indexer/cleanup_manager.py,sha256=1x2de8Mr9dL92q4ubEebsWSF_2n8Yxk549Zoh
 mcp_code_indexer/deepask_handler.py,sha256=iAFA1pKfAnurHBprIyP1TaecPzZ5YhBs-oR8Eccxoe4,18323
 mcp_code_indexer/error_handler.py,sha256=x6dHezVeKcD2ealNLBndt-3SiPiMfh9VOUNoqQSk3rI,11660
 mcp_code_indexer/file_scanner.py,sha256=ctXeZMROgDThEtjzsANTK9TbK-fhTScMBd4iyuleBT4,11734
-mcp_code_indexer/git_hook_handler.py,sha256=OMPfQlykqR2_cE5IxGqbAI92afLOOJxsvXbAQIZrdLU,36579
-mcp_code_indexer/logging_config.py,sha256=tf_U-Zz_axDXRV9s7TfHEeUrBjT1QBWkzPuiyZMffBU,10252
-mcp_code_indexer/main.py,sha256=abCHbNFUYjkJcNYsU0EPdZQI-_Gz9cQCH7dYJ5Jp7I8,31627
-mcp_code_indexer/merge_handler.py,sha256=lJR8eVq2qSrF6MW9mR3Fy8UzrNAaQ7RsI2FMNXne3vQ,14692
+mcp_code_indexer/git_hook_handler.py,sha256=y_JHj0zeTwID3oWhZHjZKeO1R0XoAifMEMwYGZnYk2w,34920
+mcp_code_indexer/logging_config.py,sha256=R5R50xFYy-flgHHh5uVGKV7JIPYKohk2RYa1eEn8kYM,10212
+mcp_code_indexer/main.py,sha256=NThiusK1ZPgxP_ZYlms4sxifcviupHa1-oH6ytbFVwQ,31122
 mcp_code_indexer/query_preprocessor.py,sha256=uHYy8FO4FTs7MFKsXoueYIafWDKOIirRgdUzwh8upb4,5773
 mcp_code_indexer/token_counter.py,sha256=WrifOkbF99nWWHlRlhCHAB2KN7qr83GOHl7apE-hJcE,8460
 mcp_code_indexer/data/stop_words_english.txt,sha256=7Zdd9ameVgA6tN_zuXROvHXD4hkWeELVywPhb7FJEkw,6343
 mcp_code_indexer/database/__init__.py,sha256=aPq_aaRp0aSwOBIq9GkuMNjmLxA411zg2vhdrAuHm-w,38
 mcp_code_indexer/database/connection_health.py,sha256=s2r9L_KipH5NlemAUDnhBQO90Dn4b_0Ht9UDs7F6QPk,24432
-mcp_code_indexer/database/database.py,sha256=4y2JqK0opz4MZk1R_zMBi5B-hRyXd_jt4cksWIiU34A,52724
+mcp_code_indexer/database/database.py,sha256=9c_DFhitSc5gRLmU2xkeeGAuRQ-mIBPE7_Xbu-vMlF4,49222
 mcp_code_indexer/database/exceptions.py,sha256=AgpRA9Z5R-GoWYdQSPeSdYvAXDopFCQkLGN3jD7Ha4E,10215
-mcp_code_indexer/database/models.py,sha256=FbNtP9Z0bDCoe8JjsYT1HWp0uYsxgZFHR0Blt3d8TBY,7054
+mcp_code_indexer/database/models.py,sha256=t4HJ2HJfRzMWt0kHjfLEh8p_ecqdQIdej5LyQYUqpsI,6858
 mcp_code_indexer/database/retry_executor.py,sha256=QUayjkCk8OsckVMYiJ_HBQ9NTUss-H8GQeUIUbbw4_U,13419
 mcp_code_indexer/middleware/__init__.py,sha256=p-mP0pMsfiU2yajCPvokCUxUEkh_lu4XJP1LyyMW2ug,220
 mcp_code_indexer/middleware/error_middleware.py,sha256=5agJTAkkPogfPGnja1V9JtG9RG-BiOALIJYctK3byJQ,11730
@@ -25,13 +24,14 @@ mcp_code_indexer/migrations/001_initial.sql,sha256=hIXkCP4LA_4A9HJ1CHU0a1DD-a6EN
 mcp_code_indexer/migrations/002_performance_indexes.sql,sha256=FlKbmcJyKAHTKmjxmpk8ABe6eMcQahz8RciRYcREY_E,2846
 mcp_code_indexer/migrations/003_project_overviews.sql,sha256=pPzn7UmJ_Bda9mJ1nYTN1GeuYwdQHC7Fva6PvWaucUw,891
 mcp_code_indexer/migrations/004_remove_branch_dependency.sql,sha256=whZvj2qfba1-Xq7Vg4IfpCpIrRKN21AdtG0gZbFSRi4,6466
+mcp_code_indexer/migrations/005_remove_git_remotes.sql,sha256=vT84AaV1hyN4zq5W67hR14TgAwhW7_RNtBHrCoksxA4,1299
 mcp_code_indexer/server/__init__.py,sha256=16xMcuriUOBlawRqWNBk6niwrvtv_JD5xvI36X1Vsmk,41
-mcp_code_indexer/server/mcp_server.py,sha256=EQnwRbjF17AdPvO_HPb6d7cmpxUN51qbyMuhQXrtetU,63168
+mcp_code_indexer/server/mcp_server.py,sha256=YEb7vNp_TALanGFlm-shAHjkuFfcE4obhVcyjrCvrJA,60194
 mcp_code_indexer/tiktoken_cache/9b5ad71b2ce5302211f9c61530b329a4922fc6a4,sha256=Ijkht27pm96ZW3_3OFE-7xAPtR0YyTWXoRO8_-hlsqc,1681126
 mcp_code_indexer/tools/__init__.py,sha256=m01mxML2UdD7y5rih_XNhNSCMzQTz7WQ_T1TeOcYlnE,49
-mcp_code_indexer-3.0.3.dist-info/licenses/LICENSE,sha256=JN9dyPPgYwH9C-UjYM7FLNZjQ6BF7kAzpF3_4PwY4rY,1086
-mcp_code_indexer-3.0.3.dist-info/METADATA,sha256=KhSmG_81Lli-5xIPfTy1uOCGYl6Ec1vqGrpaq0IE9ls,20165
-mcp_code_indexer-3.0.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-mcp_code_indexer-3.0.3.dist-info/entry_points.txt,sha256=8HqWOw1Is7jOP1bvIgaSwouvT9z_Boe-9hd4NzyJOhY,68
-mcp_code_indexer-3.0.3.dist-info/top_level.txt,sha256=yKYCM-gMGt-cnupGfAhnZaoEsROLB6DQ1KFUuyKx4rw,17
-mcp_code_indexer-3.0.3.dist-info/RECORD,,
+mcp_code_indexer-3.1.1.dist-info/licenses/LICENSE,sha256=JN9dyPPgYwH9C-UjYM7FLNZjQ6BF7kAzpF3_4PwY4rY,1086
+mcp_code_indexer-3.1.1.dist-info/METADATA,sha256=r6VEyZ8c5IH9oBQLDQy95GQzktp5i1x89lK4BchUmBg,19849
+mcp_code_indexer-3.1.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+mcp_code_indexer-3.1.1.dist-info/entry_points.txt,sha256=8HqWOw1Is7jOP1bvIgaSwouvT9z_Boe-9hd4NzyJOhY,68
+mcp_code_indexer-3.1.1.dist-info/top_level.txt,sha256=yKYCM-gMGt-cnupGfAhnZaoEsROLB6DQ1KFUuyKx4rw,17
+mcp_code_indexer-3.1.1.dist-info/RECORD,,

mcp_code_indexer/merge_handler.py

@@ -1,386 +0,0 @@
-"""
-Two-phase merge functionality for branch descriptions.
-
-This module implements conflict detection and resolution for merging
-file descriptions between branches with AI-assisted conflict resolution.
-"""
-
-import logging
-from datetime import datetime
-from typing import Dict, List, Optional, Tuple
-from uuid import uuid4
-
-from mcp_code_indexer.database.database import DatabaseManager
-from mcp_code_indexer.database.models import FileDescription
-from mcp_code_indexer.error_handler import ValidationError, DatabaseError
-from mcp_code_indexer.logging_config import get_logger
-
-logger = get_logger(__name__)
-
-
-class MergeConflict:
-    """Represents a merge conflict between file descriptions."""
-    
-    def __init__(
-        self,
-        file_path: str,
-        source_branch: str,
-        target_branch: str,
-        source_description: str,
-        target_description: str,
-        conflict_id: Optional[str] = None
-    ):
-        """
-        Initialize merge conflict.
-        
-        Args:
-            file_path: Path to conflicted file
-            source_branch: Branch being merged from
-            target_branch: Branch being merged into
-            source_description: Description from source branch
-            target_description: Description from target branch
-            conflict_id: Optional conflict identifier
-        """
-        self.file_path = file_path
-        self.source_branch = source_branch
-        self.target_branch = target_branch
-        self.source_description = source_description
-        self.target_description = target_description
-        self.conflict_id = conflict_id or str(uuid4())
-        self.resolution: Optional[str] = None
-    
-    def to_dict(self) -> Dict:
-        """Convert conflict to dictionary representation."""
-        return {
-            "conflictId": self.conflict_id,
-            "filePath": self.file_path,
-            "sourceBranch": self.source_branch,
-            "targetBranch": self.target_branch,
-            "sourceDescription": self.source_description,
-            "targetDescription": self.target_description,
-            "resolution": self.resolution
-        }
-
-
-class MergeSession:
-    """Manages a merge session with conflicts and resolutions."""
-    
-    def __init__(self, project_id: str, source_branch: str, target_branch: str):
-        """
-        Initialize merge session.
-        
-        Args:
-            project_id: Project identifier
-            source_branch: Branch being merged from
-            target_branch: Branch being merged into
-        """
-        self.session_id = str(uuid4())
-        self.project_id = project_id
-        self.source_branch = source_branch
-        self.target_branch = target_branch
-        self.conflicts: List[MergeConflict] = []
-        self.created = datetime.utcnow()
-        self.status = "pending"  # pending, resolved, aborted
-    
-    def add_conflict(self, conflict: MergeConflict) -> None:
-        """Add a conflict to the session."""
-        self.conflicts.append(conflict)
-    
-    def get_conflict_count(self) -> int:
-        """Get total number of conflicts."""
-        return len(self.conflicts)
-    
-    def get_resolved_count(self) -> int:
-        """Get number of resolved conflicts."""
-        return len([c for c in self.conflicts if c.resolution is not None])
-    
-    def is_fully_resolved(self) -> bool:
-        """Check if all conflicts are resolved."""
-        return self.get_resolved_count() == self.get_conflict_count()
-    
-    def to_dict(self) -> Dict:
-        """Convert session to dictionary representation."""
-        return {
-            "sessionId": self.session_id,
-            "projectId": self.project_id,
-            "sourceBranch": self.source_branch,
-            "targetBranch": self.target_branch,
-            "totalConflicts": self.get_conflict_count(),
-            "resolvedConflicts": self.get_resolved_count(),
-            "isFullyResolved": self.is_fully_resolved(),
-            "created": self.created.isoformat(),
-            "status": self.status,
-            "conflicts": [conflict.to_dict() for conflict in self.conflicts]
-        }
-
-
-class MergeHandler:
-    """
-    Handles two-phase merge operations for file descriptions.
-    
-    Phase 1: Detect conflicts between source and target branches
-    Phase 2: Apply resolutions and complete merge
-    """
-    
-    def __init__(self, db_manager: DatabaseManager):
-        """
-        Initialize merge handler.
-        
-        Args:
-            db_manager: Database manager instance
-        """
-        self.db_manager = db_manager
-        self._active_sessions: Dict[str, MergeSession] = {}
-    
-    async def start_merge_phase1(
-        self,
-        project_id: str,
-        source_branch: str,
-        target_branch: str
-    ) -> MergeSession:
-        """
-        Phase 1: Detect merge conflicts.
-        
-        Args:
-            project_id: Project identifier
-            source_branch: Branch to merge from
-            target_branch: Branch to merge into
-            
-        Returns:
-            MergeSession with detected conflicts
-            
-        Raises:
-            ValidationError: If branches are invalid
-            DatabaseError: If database operation fails
-        """
-        if source_branch == target_branch:
-            raise ValidationError("Source and target branches cannot be the same")
-        
-        logger.info(f"Starting merge phase 1: {source_branch} -> {target_branch}")
-        
-        try:
-            # Get file descriptions from both branches
-            source_descriptions = await self.db_manager.get_all_file_descriptions(
-                project_id, source_branch
-            )
-            target_descriptions = await self.db_manager.get_all_file_descriptions(
-                project_id, target_branch
-            )
-            
-            # Create session
-            session = MergeSession(project_id, source_branch, target_branch)
-            
-            # Build lookup dictionaries
-            source_lookup = {desc.file_path: desc for desc in source_descriptions}
-            target_lookup = {desc.file_path: desc for desc in target_descriptions}
-            
-            # Detect conflicts
-            conflicts_found = 0
-            all_files = set(source_lookup.keys()) | set(target_lookup.keys())
-            
-            for file_path in all_files:
-                source_desc = source_lookup.get(file_path)
-                target_desc = target_lookup.get(file_path)
-                
-                # Conflict occurs when:
-                # 1. File exists in both branches with different descriptions
-                # 2. File has been modified in source but also exists in target
-                if source_desc and target_desc:
-                    if source_desc.description != target_desc.description:
-                        conflict = MergeConflict(
-                            file_path=file_path,
-                            source_branch=source_branch,
-                            target_branch=target_branch,
-                            source_description=source_desc.description,
-                            target_description=target_desc.description
-                        )
-                        session.add_conflict(conflict)
-                        conflicts_found += 1
-            
-            # Store session
-            self._active_sessions[session.session_id] = session
-            
-            logger.info(f"Merge phase 1 completed: {conflicts_found} conflicts found")
-            
-            return session
-            
-        except Exception as e:
-            logger.error(f"Error in merge phase 1: {e}")
-            raise DatabaseError(f"Failed to detect merge conflicts: {e}") from e
-    
-    async def complete_merge_phase2(
-        self,
-        session_id: str,
-        conflict_resolutions: List[Dict[str, str]]
-    ) -> Dict:
-        """
-        Phase 2: Apply resolutions and complete merge.
-        
-        Args:
-            session_id: Merge session identifier
-            conflict_resolutions: List of {conflictId, resolvedDescription}
-            
-        Returns:
-            Merge result summary
-            
-        Raises:
-            ValidationError: If session not found or resolutions invalid
-            DatabaseError: If database operation fails
-        """
-        session = self._active_sessions.get(session_id)
-        if not session:
-            raise ValidationError(f"Merge session not found: {session_id}")
-        
-        logger.info(f"Starting merge phase 2 for session {session_id}")
-        
-        try:
-            # Validate and apply resolutions
-            resolution_lookup = {res["conflictId"]: res["resolvedDescription"] 
-                               for res in conflict_resolutions}
-            
-            resolved_count = 0
-            for conflict in session.conflicts:
-                if conflict.conflict_id in resolution_lookup:
-                    conflict.resolution = resolution_lookup[conflict.conflict_id]
-                    resolved_count += 1
-            
-            # Check if all conflicts are resolved
-            if not session.is_fully_resolved():
-                unresolved = session.get_conflict_count() - session.get_resolved_count()
-                raise ValidationError(
-                    f"Not all conflicts resolved: {unresolved} remaining",
-                    details={
-                        "total_conflicts": session.get_conflict_count(),
-                        "resolved_conflicts": session.get_resolved_count(),
-                        "unresolved_conflicts": unresolved
-                    }
-                )
-            
-            # Apply merge
-            merged_descriptions = []
-            
-            # Get all descriptions from source branch
-            source_descriptions = await self.db_manager.get_all_file_descriptions(
-                session.project_id, session.source_branch
-            )
-            
-            # Get existing target descriptions
-            target_descriptions = await self.db_manager.get_all_file_descriptions(
-                session.project_id, session.target_branch
-            )
-            
-            target_lookup = {desc.file_path: desc for desc in target_descriptions}
-            
-            # Apply resolved descriptions
-            for source_desc in source_descriptions:
-                resolved_conflict = next(
-                    (c for c in session.conflicts if c.file_path == source_desc.file_path),
-                    None
-                )
-                
-                if resolved_conflict:
-                    # Use resolved description
-                    new_desc = FileDescription(
-                        project_id=session.project_id,
-                        branch=session.target_branch,
-                        file_path=source_desc.file_path,
-                        description=resolved_conflict.resolution,
-                        file_hash=source_desc.file_hash,
-                        last_modified=datetime.utcnow(),
-                        version=1,
-                        source_project_id=source_desc.source_project_id
-                    )
-                else:
-                    # No conflict, copy from source
-                    new_desc = FileDescription(
-                        project_id=session.project_id,
-                        branch=session.target_branch,
-                        file_path=source_desc.file_path,
-                        description=source_desc.description,
-                        file_hash=source_desc.file_hash,
-                        last_modified=datetime.utcnow(),
-                        version=1,
-                        source_project_id=source_desc.source_project_id
-                    )
-                
-                merged_descriptions.append(new_desc)
-            
-            # Batch update target branch
-            await self.db_manager.batch_create_file_descriptions(merged_descriptions)
-            
-            # Mark session as completed
-            session.status = "resolved"
-            
-            result = {
-                "success": True,
-                "sessionId": session_id,
-                "sourceBranch": session.source_branch,
-                "targetBranch": session.target_branch,
-                "totalConflicts": session.get_conflict_count(),
-                "resolvedConflicts": session.get_resolved_count(),
-                "mergedFiles": len(merged_descriptions),
-                "message": f"Successfully merged {len(merged_descriptions)} files from {session.source_branch} to {session.target_branch}"
-            }
-            
-            logger.info(f"Merge phase 2 completed successfully: {len(merged_descriptions)} files merged")
-            
-            # Clean up session
-            del self._active_sessions[session_id]
-            
-            return result
-            
-        except Exception as e:
-            if session:
-                session.status = "aborted"
-            logger.error(f"Error in merge phase 2: {e}")
-            raise DatabaseError(f"Failed to complete merge: {e}") from e
-    
-    def get_session(self, session_id: str) -> Optional[MergeSession]:
-        """Get merge session by ID."""
-        return self._active_sessions.get(session_id)
-    
-    def get_active_sessions(self) -> List[MergeSession]:
-        """Get all active merge sessions."""
-        return list(self._active_sessions.values())
-    
-    def abort_session(self, session_id: str) -> bool:
-        """
-        Abort a merge session.
-        
-        Args:
-            session_id: Session to abort
-            
-        Returns:
-            True if session was aborted
-        """
-        session = self._active_sessions.get(session_id)
-        if session:
-            session.status = "aborted"
-            del self._active_sessions[session_id]
-            logger.info(f"Merge session {session_id} aborted")
-            return True
-        return False
-    
-    def cleanup_old_sessions(self, max_age_hours: int = 24) -> int:
-        """
-        Clean up old merge sessions.
-        
-        Args:
-            max_age_hours: Maximum age of sessions to keep
-            
-        Returns:
-            Number of sessions cleaned up
-        """
-        cutoff_time = datetime.utcnow() - datetime.timedelta(hours=max_age_hours)
-        old_sessions = [
-            session_id for session_id, session in self._active_sessions.items()
-            if session.created < cutoff_time
-        ]
-        
-        for session_id in old_sessions:
-            del self._active_sessions[session_id]
-        
-        if old_sessions:
-            logger.info(f"Cleaned up {len(old_sessions)} old merge sessions")
-        
-        return len(old_sessions)