mcp-vector-search 0.8.6__tar.gz → 0.9.0__tar.gz

{mcp_vector_search-0.8.6 → mcp_vector_search-0.9.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mcp-vector-search
-Version: 0.8.6
+Version: 0.9.0
 Summary: CLI-first semantic code search with MCP integration
 Project-URL: Homepage, https://github.com/bobmatnyc/mcp-vector-search
 Project-URL: Documentation, https://mcp-vector-search.readthedocs.io

{mcp_vector_search-0.8.6 → mcp_vector_search-0.9.0}/src/mcp_vector_search/__init__.py

@@ -1,7 +1,7 @@
 """MCP Vector Search - CLI-first semantic code search with MCP integration."""
 
-__version__ = "0.8.6"
-__build__ = "35"
+__version__ = "0.9.0"
+__build__ = "37"
 __author__ = "Robert Matsuoka"
 __email__ = "bobmatnyc@gmail.com"
 

{mcp_vector_search-0.8.6 → mcp_vector_search-0.9.0}/src/mcp_vector_search/cli/commands/index.py

@@ -330,7 +330,7 @@ async def _run_batch_indexing(
                 console.print(
                     f"[yellow]⚠ {failed_count} files failed to index[/yellow]"
                 )
-                error_log_path = project_root / ".mcp-vector-search" / "indexing_errors.log"
+                error_log_path = indexer.project_root / ".mcp-vector-search" / "indexing_errors.log"
                 if error_log_path.exists():
                     console.print(
                         f"[dim]  → See details in: {error_log_path}[/dim]"

{mcp_vector_search-0.8.6 → mcp_vector_search-0.9.0}/src/mcp_vector_search/cli/commands/visualize.py

@@ -72,48 +72,116 @@ async def _export_chunks(output: Path, file_filter: str | None) -> None:
 
         # Get all chunks with metadata
         console.print("[cyan]Fetching chunks from database...[/cyan]")
+        chunks = await database.get_all_chunks()
 
-        # Query all chunks (we'll use a dummy search to get all)
-        stats = await database.get_stats()
-
-        if stats.total_chunks == 0:
+        if len(chunks) == 0:
             console.print("[yellow]No chunks found in index. Run 'mcp-vector-search index' first.[/yellow]")
             raise typer.Exit(1)
 
+        console.print(f"[green]✓[/green] Retrieved {len(chunks)} chunks")
+
+        # Apply file filter if specified
+        if file_filter:
+            from fnmatch import fnmatch
+            chunks = [c for c in chunks if fnmatch(str(c.file_path), file_filter)]
+            console.print(f"[cyan]Filtered to {len(chunks)} chunks matching '{file_filter}'[/cyan]")
+
+        # Collect subprojects for monorepo support
+        subprojects = {}
+        for chunk in chunks:
+            if chunk.subproject_name and chunk.subproject_name not in subprojects:
+                subprojects[chunk.subproject_name] = {
+                    "name": chunk.subproject_name,
+                    "path": chunk.subproject_path,
+                    "color": _get_subproject_color(chunk.subproject_name, len(subprojects)),
+                }
+
         # Build graph data structure
         nodes = []
         links = []
+        chunk_id_map = {}  # Map chunk IDs to array indices
+
+        # Add subproject root nodes for monorepos
+        if subprojects:
+            console.print(f"[cyan]Detected monorepo with {len(subprojects)} subprojects[/cyan]")
+            for sp_name, sp_data in subprojects.items():
+                node = {
+                    "id": f"subproject_{sp_name}",
+                    "name": sp_name,
+                    "type": "subproject",
+                    "file_path": sp_data["path"] or "",
+                    "start_line": 0,
+                    "end_line": 0,
+                    "complexity": 0,
+                    "color": sp_data["color"],
+                    "depth": 0,
+                }
+                nodes.append(node)
+
+        # Add chunk nodes
+        for chunk in chunks:
+            node = {
+                "id": chunk.chunk_id or chunk.id,
+                "name": chunk.function_name or chunk.class_name or f"L{chunk.start_line}",
+                "type": chunk.chunk_type,
+                "file_path": str(chunk.file_path),
+                "start_line": chunk.start_line,
+                "end_line": chunk.end_line,
+                "complexity": chunk.complexity_score,
+                "parent_id": chunk.parent_chunk_id,
+                "depth": chunk.chunk_depth,
+            }
 
-        # We need to query the database to get actual chunk data
-        # Since there's no "get all chunks" method, we'll work with the stats
-        # In a real implementation, you would add a method to get all chunks
+            # Add subproject info for monorepos
+            if chunk.subproject_name:
+                node["subproject"] = chunk.subproject_name
+                node["color"] = subprojects[chunk.subproject_name]["color"]
 
-        console.print(f"[yellow]Note: Full chunk export requires database enhancement.[/yellow]")
-        console.print(f"[cyan]Creating placeholder graph with {stats.total_chunks} chunks...[/cyan]")
+            nodes.append(node)
+            chunk_id_map[node["id"]] = len(nodes) - 1
+
+        # Build hierarchical links from parent-child relationships
+        for chunk in chunks:
+            chunk_id = chunk.chunk_id or chunk.id
+
+            # Link to subproject root if in monorepo
+            if chunk.subproject_name and not chunk.parent_chunk_id:
+                links.append({
+                    "source": f"subproject_{chunk.subproject_name}",
+                    "target": chunk_id,
+                })
+
+            # Link to parent chunk
+            if chunk.parent_chunk_id and chunk.parent_chunk_id in chunk_id_map:
+                links.append({
+                    "source": chunk.parent_chunk_id,
+                    "target": chunk_id,
+                })
 
-        # Create sample graph structure
+        # Parse inter-project dependencies for monorepos
+        if subprojects:
+            console.print("[cyan]Parsing inter-project dependencies...[/cyan]")
+            dep_links = _parse_project_dependencies(
+                project_manager.project_root,
+                subprojects
+            )
+            links.extend(dep_links)
+            if dep_links:
+                console.print(f"[green]✓[/green] Found {len(dep_links)} inter-project dependencies")
+
+        # Get stats
+        stats = await database.get_stats()
+
+        # Build final graph data
         graph_data = {
-            "nodes": [
-                {
-                    "id": f"chunk_{i}",
-                    "name": f"Chunk {i}",
-                    "type": "code",
-                    "file_path": "example.py",
-                    "start_line": i * 10,
-                    "end_line": (i + 1) * 10,
-                    "complexity": 1.0 + (i % 5),
-                }
-                for i in range(min(stats.total_chunks, 50))  # Limit to 50 for demo
-            ],
-            "links": [
-                {"source": f"chunk_{i}", "target": f"chunk_{i+1}"}
-                for i in range(min(stats.total_chunks - 1, 49))
-            ],
+            "nodes": nodes,
+            "links": links,
             "metadata": {
-                "total_chunks": stats.total_chunks,
+                "total_chunks": len(chunks),
                 "total_files": stats.total_files,
                 "languages": stats.languages,
-                "export_note": "This is a placeholder. Full export requires database enhancement.",
+                "is_monorepo": len(subprojects) > 0,
+                "subprojects": list(subprojects.keys()) if subprojects else [],
             },
         }
 
@@ -129,7 +197,8 @@ async def _export_chunks(output: Path, file_filter: str | None) -> None:
             Panel.fit(
                 f"[green]✓[/green] Exported graph data to [cyan]{output}[/cyan]\n\n"
                 f"Nodes: {len(graph_data['nodes'])}\n"
-                f"Links: {len(graph_data['links'])}\n\n"
+                f"Links: {len(graph_data['links'])}\n"
+                f"{'Subprojects: ' + str(len(subprojects)) if subprojects else ''}\n\n"
                 f"[dim]Next: Run 'mcp-vector-search visualize serve' to view[/dim]",
                 title="Export Complete",
                 border_style="green",
@@ -142,6 +211,69 @@ async def _export_chunks(output: Path, file_filter: str | None) -> None:
         raise typer.Exit(1)
 
 
+def _get_subproject_color(subproject_name: str, index: int) -> str:
+    """Get a consistent color for a subproject."""
+    # Color palette for subprojects (GitHub-style colors)
+    colors = [
+        "#238636",  # Green
+        "#1f6feb",  # Blue
+        "#d29922",  # Yellow
+        "#8957e5",  # Purple
+        "#da3633",  # Red
+        "#bf8700",  # Orange
+        "#1a7f37",  # Dark green
+        "#0969da",  # Dark blue
+    ]
+    return colors[index % len(colors)]
+
+
+def _parse_project_dependencies(project_root: Path, subprojects: dict) -> list[dict]:
+    """Parse package.json files to find inter-project dependencies.
+
+    Args:
+        project_root: Root directory of the monorepo
+        subprojects: Dictionary of subproject information
+
+    Returns:
+        List of dependency links between subprojects
+    """
+    dependency_links = []
+
+    for sp_name, sp_data in subprojects.items():
+        package_json = project_root / sp_data["path"] / "package.json"
+
+        if not package_json.exists():
+            continue
+
+        try:
+            with open(package_json) as f:
+                package_data = json.load(f)
+
+            # Check all dependency types
+            all_deps = {}
+            for dep_type in ["dependencies", "devDependencies", "peerDependencies"]:
+                if dep_type in package_data:
+                    all_deps.update(package_data[dep_type])
+
+            # Find dependencies on other subprojects
+            for dep_name in all_deps.keys():
+                # Check if this dependency is another subproject
+                for other_sp_name in subprojects.keys():
+                    if other_sp_name != sp_name and dep_name == other_sp_name:
+                        # Found inter-project dependency
+                        dependency_links.append({
+                            "source": f"subproject_{sp_name}",
+                            "target": f"subproject_{other_sp_name}",
+                            "type": "dependency",
+                        })
+
+        except Exception as e:
+            logger.debug(f"Failed to parse {package_json}: {e}")
+            continue
+
+    return dependency_links
+
+
 @app.command()
 def serve(
     port: int = typer.Option(8080, "--port", "-p", help="Port for visualization server"),
@@ -344,6 +476,7 @@ def _create_visualization_html(html_file: Path) -> None:
         .node.function circle { fill: #d29922; }
         .node.method circle { fill: #8957e5; }
         .node.code circle { fill: #6e7681; }
+        .node.subproject circle { fill: #da3633; stroke-width: 3px; }
 
         .node text {
             font-size: 11px;
@@ -359,6 +492,13 @@ def _create_visualization_html(html_file: Path) -> None:
             stroke-width: 1.5px;
         }
 
+        .link.dependency {
+            stroke: #d29922;
+            stroke-opacity: 0.8;
+            stroke-width: 2px;
+            stroke-dasharray: 5,5;
+        }
+
         .tooltip {
             position: absolute;
             padding: 12px;
@@ -391,6 +531,9 @@ def _create_visualization_html(html_file: Path) -> None:
 
         <h3>Legend</h3>
         <div class="legend">
+            <div class="legend-item">
+                <span class="legend-color" style="background: #da3633;"></span> Subproject
+            </div>
             <div class="legend-item">
                 <span class="legend-color" style="background: #238636;"></span> Module
             </div>
@@ -408,6 +551,11 @@ def _create_visualization_html(html_file: Path) -> None:
             </div>
         </div>
 
+        <div id="subprojects-legend" style="display: none;">
+            <h3>Subprojects</h3>
+            <div class="legend" id="subprojects-list"></div>
+        </div>
+
         <div class="stats" id="stats"></div>
     </div>
 
@@ -439,10 +587,17 @@ def _create_visualization_html(html_file: Path) -> None:
             allNodes = data.nodes;
             allLinks = data.links;
 
-            // Find root nodes (nodes without parents or depth 0/1)
-            const rootNodes = allNodes.filter(n =>
-                !n.parent_id || n.depth === 0 || n.depth === 1 || n.type === 'module'
-            );
+            // Find root nodes
+            let rootNodes;
+            if (data.metadata && data.metadata.is_monorepo) {
+                // In monorepos, subproject nodes are roots
+                rootNodes = allNodes.filter(n => n.type === 'subproject');
+            } else {
+                // Regular projects: nodes without parents or depth 0/1
+                rootNodes = allNodes.filter(n =>
+                    !n.parent_id || n.depth === 0 || n.depth === 1 || n.type === 'module'
+                );
+            }
 
             // Start with only root nodes visible
             visibleNodes = new Set(rootNodes.map(n => n.id));
@@ -470,7 +625,7 @@ def _create_visualization_html(html_file: Path) -> None:
                 .selectAll("line")
                 .data(visibleLinks)
                 .join("line")
-                .attr("class", "link");
+                .attr("class", d => d.type === "dependency" ? "link dependency" : "link");
 
             const node = g.append("g")
                 .selectAll("g")
@@ -484,9 +639,13 @@ def _create_visualization_html(html_file: Path) -> None:
 
             // Add circles with expand indicator
             node.append("circle")
-                .attr("r", d => d.complexity ? Math.min(8 + d.complexity * 2, 25) : 12)
+                .attr("r", d => {
+                    if (d.type === 'subproject') return 20;
+                    return d.complexity ? Math.min(8 + d.complexity * 2, 25) : 12;
+                })
                 .attr("stroke", d => hasChildren(d) ? "#ffffff" : "none")
-                .attr("stroke-width", d => hasChildren(d) ? 2 : 0);
+                .attr("stroke-width", d => hasChildren(d) ? 2 : 0)
+                .style("fill", d => d.color || null);  // Use custom color if available
 
             // Add expand/collapse indicator
             node.filter(d => hasChildren(d))
@@ -620,7 +779,27 @@ def _create_visualization_html(html_file: Path) -> None:
                 <div>Nodes: ${data.nodes.length}</div>
                 <div>Links: ${data.links.length}</div>
                 ${data.metadata ? `<div>Files: ${data.metadata.total_files || 'N/A'}</div>` : ''}
+                ${data.metadata && data.metadata.is_monorepo ? `<div>Monorepo: ${data.metadata.subprojects.length} subprojects</div>` : ''}
             `);
+
+            // Show subproject legend if monorepo
+            if (data.metadata && data.metadata.is_monorepo && data.metadata.subprojects.length > 0) {
+                const subprojectsLegend = d3.select("#subprojects-legend");
+                const subprojectsList = d3.select("#subprojects-list");
+
+                subprojectsLegend.style("display", "block");
+
+                // Get subproject nodes with colors
+                const subprojectNodes = allNodes.filter(n => n.type === 'subproject');
+
+                subprojectsList.html(
+                    subprojectNodes.map(sp =>
+                        `<div class="legend-item">
+                            <span class="legend-color" style="background: ${sp.color};"></span> ${sp.name}
+                        </div>`
+                    ).join('')
+                );
+            }
         }
 
         // Auto-load graph data on page load

{mcp_vector_search-0.8.6 → mcp_vector_search-0.9.0}/src/mcp_vector_search/core/database.py

@@ -98,6 +98,15 @@ class VectorDatabase(ABC):
         """Reset the database (delete all data)."""
         ...
 
+    @abstractmethod
+    async def get_all_chunks(self) -> list[CodeChunk]:
+        """Get all chunks from the database.
+
+        Returns:
+            List of all code chunks with metadata
+        """
+        ...
+
     @abstractmethod
     async def health_check(self) -> bool:
         """Check database health and integrity.
@@ -467,6 +476,59 @@ class ChromaVectorDatabase(VectorDatabase):
                 logger.error(f"Failed to reset database: {e}")
                 raise DatabaseError(f"Failed to reset database: {e}") from e
 
+    async def get_all_chunks(self) -> list[CodeChunk]:
+        """Get all chunks from the database.
+
+        Returns:
+            List of all code chunks with metadata
+        """
+        if not self._collection:
+            raise DatabaseNotInitializedError("Database not initialized")
+
+        try:
+            # Get all documents from collection
+            results = self._collection.get(
+                include=["metadatas", "documents"]
+            )
+
+            chunks = []
+            if results and results.get("ids"):
+                for i, chunk_id in enumerate(results["ids"]):
+                    metadata = results["metadatas"][i]
+                    content = results["documents"][i]
+
+                    chunk = CodeChunk(
+                        content=content,
+                        file_path=Path(metadata["file_path"]),
+                        start_line=metadata["start_line"],
+                        end_line=metadata["end_line"],
+                        language=metadata["language"],
+                        chunk_type=metadata.get("chunk_type", "code"),
+                        function_name=metadata.get("function_name"),
+                        class_name=metadata.get("class_name"),
+                        docstring=metadata.get("docstring"),
+                        imports=metadata.get("imports", []),
+                        complexity_score=metadata.get("complexity_score", 0.0),
+                        chunk_id=metadata.get("chunk_id"),
+                        parent_chunk_id=metadata.get("parent_chunk_id"),
+                        child_chunk_ids=metadata.get("child_chunk_ids", []),
+                        chunk_depth=metadata.get("chunk_depth", 0),
+                        decorators=metadata.get("decorators", []),
+                        parameters=metadata.get("parameters", []),
+                        return_type=metadata.get("return_type"),
+                        type_annotations=metadata.get("type_annotations", {}),
+                        subproject_name=metadata.get("subproject_name"),
+                        subproject_path=metadata.get("subproject_path"),
+                    )
+                    chunks.append(chunk)
+
+            logger.debug(f"Retrieved {len(chunks)} chunks from database")
+            return chunks
+
+        except Exception as e:
+            logger.error(f"Failed to get all chunks: {e}")
+            raise DatabaseError(f"Failed to get all chunks: {e}") from e
+
     def _create_searchable_text(self, chunk: CodeChunk) -> str:
         """Create optimized searchable text from code chunk."""
         parts = [chunk.content]
@@ -914,6 +976,57 @@ class PooledChromaVectorDatabase(VectorDatabase):
             logger.error(f"Failed to reset database: {e}")
             raise DatabaseError(f"Failed to reset database: {e}") from e
 
+    async def get_all_chunks(self) -> list[CodeChunk]:
+        """Get all chunks from the database using pooled connection.
+
+        Returns:
+            List of all code chunks with metadata
+        """
+        try:
+            async with self._pool.get_connection() as conn:
+                # Get all documents from collection
+                results = conn.collection.get(
+                    include=["metadatas", "documents"]
+                )
+
+                chunks = []
+                if results and results.get("ids"):
+                    for i, chunk_id in enumerate(results["ids"]):
+                        metadata = results["metadatas"][i]
+                        content = results["documents"][i]
+
+                        chunk = CodeChunk(
+                            content=content,
+                            file_path=Path(metadata["file_path"]),
+                            start_line=metadata["start_line"],
+                            end_line=metadata["end_line"],
+                            language=metadata["language"],
+                            chunk_type=metadata.get("chunk_type", "code"),
+                            function_name=metadata.get("function_name"),
+                            class_name=metadata.get("class_name"),
+                            docstring=metadata.get("docstring"),
+                            imports=metadata.get("imports", []),
+                            complexity_score=metadata.get("complexity_score", 0.0),
+                            chunk_id=metadata.get("chunk_id"),
+                            parent_chunk_id=metadata.get("parent_chunk_id"),
+                            child_chunk_ids=metadata.get("child_chunk_ids", []),
+                            chunk_depth=metadata.get("chunk_depth", 0),
+                            decorators=metadata.get("decorators", []),
+                            parameters=metadata.get("parameters", []),
+                            return_type=metadata.get("return_type"),
+                            type_annotations=metadata.get("type_annotations", {}),
+                            subproject_name=metadata.get("subproject_name"),
+                            subproject_path=metadata.get("subproject_path"),
+                        )
+                        chunks.append(chunk)
+
+                logger.debug(f"Retrieved {len(chunks)} chunks from database")
+                return chunks
+
+        except Exception as e:
+            logger.error(f"Failed to get all chunks: {e}")
+            raise DatabaseError(f"Failed to get all chunks: {e}") from e
+
     def _build_where_clause(self, filters: dict[str, Any]) -> dict[str, Any] | None:
         """Build ChromaDB where clause from filters."""
         if not filters:

{mcp_vector_search-0.8.6 → mcp_vector_search-0.9.0}/src/mcp_vector_search/core/indexer.py

@@ -13,6 +13,7 @@ from .. import __version__
 from ..config.defaults import DEFAULT_IGNORE_PATTERNS
 from ..parsers.registry import get_parser_registry
 from ..utils.gitignore import create_gitignore_parser
+from ..utils.monorepo import MonorepoDetector
 from .database import VectorDatabase
 from .exceptions import ParsingError
 from .models import CodeChunk
@@ -72,6 +73,14 @@ class SemanticIndexer:
             logger.warning(f"Failed to load gitignore patterns: {e}")
             self.gitignore_parser = None
 
+        # Initialize monorepo detector
+        self.monorepo_detector = MonorepoDetector(project_root)
+        if self.monorepo_detector.is_monorepo():
+            subprojects = self.monorepo_detector.detect_subprojects()
+            logger.info(f"Detected monorepo with {len(subprojects)} subprojects")
+            for sp in subprojects:
+                logger.debug(f"  - {sp.name} ({sp.relative_path})")
+
     async def index_project(
         self,
         force_reindex: bool = False,
@@ -519,7 +528,7 @@ class SemanticIndexer:
             file_path: Path to the file to parse
 
         Returns:
-            List of code chunks
+            List of code chunks with subproject information
         """
         try:
             # Get appropriate parser
@@ -531,6 +540,13 @@ class SemanticIndexer:
             # Filter out empty chunks
             valid_chunks = [chunk for chunk in chunks if chunk.content.strip()]
 
+            # Assign subproject information for monorepos
+            subproject = self.monorepo_detector.get_subproject_for_file(file_path)
+            if subproject:
+                for chunk in valid_chunks:
+                    chunk.subproject_name = subproject.name
+                    chunk.subproject_path = subproject.relative_path
+
             return valid_chunks
 
         except Exception as e:

{mcp_vector_search-0.8.6 → mcp_vector_search-0.9.0}/src/mcp_vector_search/core/models.py

@@ -37,6 +37,10 @@ class CodeChunk:
     return_type: str | None = None
     type_annotations: dict[str, str] = None
 
+    # Enhancement 5: Monorepo support
+    subproject_name: str | None = None  # "ewtn-plus-foundation"
+    subproject_path: str | None = None  # Relative path from root
+
     def __post_init__(self) -> None:
         """Initialize default values and generate chunk ID."""
         if self.imports is None:
@@ -93,6 +97,8 @@ class CodeChunk:
             "parameters": self.parameters,
             "return_type": self.return_type,
             "type_annotations": self.type_annotations,
+            "subproject_name": self.subproject_name,
+            "subproject_path": self.subproject_path,
         }
 
     @classmethod
@@ -118,6 +124,8 @@ class CodeChunk:
             parameters=data.get("parameters", []),
             return_type=data.get("return_type"),
             type_annotations=data.get("type_annotations", {}),
+            subproject_name=data.get("subproject_name"),
+            subproject_path=data.get("subproject_path"),
         )