mcp-vector-search 0.8.7__py3-none-any.whl → 0.9.1__py3-none-any.whl

mcp_vector_search/__init__.py

@@ -1,7 +1,7 @@
 """MCP Vector Search - CLI-first semantic code search with MCP integration."""
 
-__version__ = "0.8.7"
-__build__ = "36"
+__version__ = "0.9.1"
+__build__ = "38"
 __author__ = "Robert Matsuoka"
 __email__ = "bobmatnyc@gmail.com"
 

mcp_vector_search/cli/commands/index.py

@@ -332,6 +332,8 @@ async def _run_batch_indexing(
                 )
                 error_log_path = indexer.project_root / ".mcp-vector-search" / "indexing_errors.log"
                 if error_log_path.exists():
+                    # Prune log to keep only last 1000 errors
+                    _prune_error_log(error_log_path, max_lines=1000)
                     console.print(
                         f"[dim]  → See details in: {error_log_path}[/dim]"
                     )
@@ -692,5 +694,28 @@ def health_cmd(
     health_main(project_root=project_root, repair=repair)
 
 
+def _prune_error_log(log_path: Path, max_lines: int = 1000) -> None:
+    """Prune error log to keep only the most recent N lines.
+
+    Args:
+        log_path: Path to the error log file
+        max_lines: Maximum number of lines to keep (default: 1000)
+    """
+    try:
+        with open(log_path, 'r') as f:
+            lines = f.readlines()
+
+        if len(lines) > max_lines:
+            # Keep only the last max_lines lines
+            pruned_lines = lines[-max_lines:]
+
+            with open(log_path, 'w') as f:
+                f.writelines(pruned_lines)
+
+            logger.debug(f"Pruned error log from {len(lines)} to {len(pruned_lines)} lines")
+    except Exception as e:
+        logger.warning(f"Failed to prune error log: {e}")
+
+
 if __name__ == "__main__":
     index_app()

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/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/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/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"),
         )
 
 

mcp_vector_search/utils/monorepo.py

@@ -0,0 +1,277 @@
+"""Monorepo detection and subproject identification."""
+
+import json
+from pathlib import Path
+from typing import NamedTuple
+
+from loguru import logger
+
+
+class Subproject(NamedTuple):
+    """Represents a subproject in a monorepo."""
+
+    name: str  # "ewtn-plus-foundation"
+    path: Path  # Absolute path to subproject
+    relative_path: str  # Relative to monorepo root
+
+
+class MonorepoDetector:
+    """Detects monorepo structure and identifies subprojects."""
+
+    def __init__(self, project_root: Path):
+        """Initialize monorepo detector.
+
+        Args:
+            project_root: Root directory of the project
+        """
+        self.project_root = project_root
+        self._subprojects: list[Subproject] | None = None
+
+    def is_monorepo(self) -> bool:
+        """Check if project is a monorepo.
+
+        Returns:
+            True if monorepo structure detected
+        """
+        return bool(self.detect_subprojects())
+
+    def detect_subprojects(self) -> list[Subproject]:
+        """Detect all subprojects in the monorepo.
+
+        Returns:
+            List of detected subprojects
+        """
+        if self._subprojects is not None:
+            return self._subprojects
+
+        subprojects = []
+
+        # Try package.json workspaces (npm/yarn/pnpm)
+        subprojects.extend(self._detect_npm_workspaces())
+
+        # Try lerna.json
+        if not subprojects:
+            subprojects.extend(self._detect_lerna_packages())
+
+        # Try pnpm-workspace.yaml
+        if not subprojects:
+            subprojects.extend(self._detect_pnpm_workspaces())
+
+        # Try nx workspace
+        if not subprojects:
+            subprojects.extend(self._detect_nx_workspace())
+
+        # Fallback: Look for multiple package.json files
+        if not subprojects:
+            subprojects.extend(self._detect_by_package_json())
+
+        self._subprojects = subprojects
+        logger.debug(f"Detected {len(subprojects)} subprojects in {self.project_root}")
+
+        return subprojects
+
+    def _detect_npm_workspaces(self) -> list[Subproject]:
+        """Detect npm/yarn/pnpm workspaces from package.json.
+
+        Returns:
+            List of subprojects from workspaces
+        """
+        package_json = self.project_root / "package.json"
+        if not package_json.exists():
+            return []
+
+        try:
+            with open(package_json) as f:
+                data = json.load(f)
+
+            workspaces = data.get("workspaces", [])
+
+            # Handle both array and object format
+            if isinstance(workspaces, dict):
+                workspaces = workspaces.get("packages", [])
+
+            return self._expand_workspace_patterns(workspaces)
+
+        except Exception as e:
+            logger.debug(f"Failed to parse package.json workspaces: {e}")
+            return []
+
+    def _detect_lerna_packages(self) -> list[Subproject]:
+        """Detect lerna packages from lerna.json.
+
+        Returns:
+            List of subprojects from lerna
+        """
+        lerna_json = self.project_root / "lerna.json"
+        if not lerna_json.exists():
+            return []
+
+        try:
+            with open(lerna_json) as f:
+                data = json.load(f)
+
+            packages = data.get("packages", ["packages/*"])
+            return self._expand_workspace_patterns(packages)
+
+        except Exception as e:
+            logger.debug(f"Failed to parse lerna.json: {e}")
+            return []
+
+    def _detect_pnpm_workspaces(self) -> list[Subproject]:
+        """Detect pnpm workspaces from pnpm-workspace.yaml.
+
+        Returns:
+            List of subprojects from pnpm
+        """
+        pnpm_workspace = self.project_root / "pnpm-workspace.yaml"
+        if not pnpm_workspace.exists():
+            return []
+
+        try:
+            import yaml
+
+            with open(pnpm_workspace) as f:
+                data = yaml.safe_load(f)
+
+            packages = data.get("packages", [])
+            return self._expand_workspace_patterns(packages)
+
+        except ImportError:
+            logger.debug("pyyaml not installed, skipping pnpm-workspace.yaml detection")
+            return []
+        except Exception as e:
+            logger.debug(f"Failed to parse pnpm-workspace.yaml: {e}")
+            return []
+
+    def _detect_nx_workspace(self) -> list[Subproject]:
+        """Detect nx workspace projects.
+
+        Returns:
+            List of subprojects from nx workspace
+        """
+        nx_json = self.project_root / "nx.json"
+        workspace_json = self.project_root / "workspace.json"
+
+        if not (nx_json.exists() or workspace_json.exists()):
+            return []
+
+        # Nx projects are typically in apps/ and libs/
+        subprojects = []
+        for base_dir in ["apps", "libs", "packages"]:
+            base_path = self.project_root / base_dir
+            if base_path.exists():
+                for subdir in base_path.iterdir():
+                    if subdir.is_dir() and not subdir.name.startswith("."):
+                        package_json = subdir / "package.json"
+                        name = self._get_package_name(package_json) or subdir.name
+                        relative = str(subdir.relative_to(self.project_root))
+                        subprojects.append(Subproject(name, subdir, relative))
+
+        return subprojects
+
+    def _detect_by_package_json(self) -> list[Subproject]:
+        """Fallback: Find all directories with package.json.
+
+        Returns:
+            List of subprojects by package.json presence
+        """
+        subprojects = []
+
+        # Only search up to 3 levels deep
+        for package_json in self.project_root.rglob("package.json"):
+            # Skip node_modules
+            if "node_modules" in package_json.parts:
+                continue
+
+            # Skip root package.json
+            if package_json.parent == self.project_root:
+                continue
+
+            # Check depth
+            relative_parts = package_json.relative_to(self.project_root).parts
+            if len(relative_parts) > 4:  # Too deep
+                continue
+
+            subdir = package_json.parent
+            name = self._get_package_name(package_json) or subdir.name
+            relative = str(subdir.relative_to(self.project_root))
+            subprojects.append(Subproject(name, subdir, relative))
+
+        return subprojects
+
+    def _expand_workspace_patterns(self, patterns: list[str]) -> list[Subproject]:
+        """Expand workspace glob patterns to actual directories.
+
+        Args:
+            patterns: List of glob patterns (e.g., ["packages/*", "apps/*"])
+
+        Returns:
+            List of subprojects matching patterns
+        """
+        subprojects = []
+
+        for pattern in patterns:
+            # Remove negation patterns (e.g., "!packages/excluded")
+            if pattern.startswith("!"):
+                continue
+
+            # Expand glob pattern
+            for path in self.project_root.glob(pattern):
+                if not path.is_dir():
+                    continue
+
+                if path.name.startswith("."):
+                    continue
+
+                # Try to get name from package.json
+                package_json = path / "package.json"
+                name = self._get_package_name(package_json) or path.name
+                relative = str(path.relative_to(self.project_root))
+
+                subprojects.append(Subproject(name, path, relative))
+
+        return subprojects
+
+    def _get_package_name(self, package_json: Path) -> str | None:
+        """Get package name from package.json.
+
+        Args:
+            package_json: Path to package.json file
+
+        Returns:
+            Package name or None
+        """
+        if not package_json.exists():
+            return None
+
+        try:
+            with open(package_json) as f:
+                data = json.load(f)
+            return data.get("name")
+        except Exception:
+            return None
+
+    def get_subproject_for_file(self, file_path: Path) -> Subproject | None:
+        """Determine which subproject a file belongs to.
+
+        Args:
+            file_path: Path to file
+
+        Returns:
+            Subproject containing the file, or None
+        """
+        subprojects = self.detect_subprojects()
+
+        if not subprojects:
+            return None
+
+        # Find the most specific (deepest) subproject containing this file
+        matching_subprojects = [
+            sp for sp in subprojects if file_path.is_relative_to(sp.path)
+        ]
+
+        if not matching_subprojects:
+            return None
+
+        # Return the deepest match (longest path)
+        return max(matching_subprojects, key=lambda sp: len(sp.path.parts))

{mcp_vector_search-0.8.7.dist-info → mcp_vector_search-0.9.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mcp-vector-search
-Version: 0.8.7
+Version: 0.9.1
 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.7.dist-info → mcp_vector_search-0.9.1.dist-info}/RECORD

@@ -1,4 +1,4 @@
-mcp_vector_search/__init__.py,sha256=kjU0gRV7u0d23c46XZySbs-fn3sxnWAP3tg6H9X9iws,299
+mcp_vector_search/__init__.py,sha256=wmIPI3OtTC0MnYzNIIhOfn-WL_Wne538UHx6NYSGYos,299
 mcp_vector_search/py.typed,sha256=lCKeV9Qcn9sGtbRsgg-LJO2ZwWRuknnnlmomq3bJFH0,43
 mcp_vector_search/cli/__init__.py,sha256=TNB7CaOASz8u3yHWLbNmo8-GtHF0qwUjVKWAuNphKgo,40
 mcp_vector_search/cli/didyoumean.py,sha256=F_ss-EX4F9RgnMsEhdTwLpyNCah9SqnBZc2tBtzASck,15918
@@ -12,14 +12,14 @@ mcp_vector_search/cli/commands/__init__.py,sha256=vQls-YKZ54YEwmf7g1dL0T2SS9D4pd
 mcp_vector_search/cli/commands/auto_index.py,sha256=imVVbxWRlA128NPdK9BetNNl3ELrsdq-hqcsLqyAmoM,12712
 mcp_vector_search/cli/commands/config.py,sha256=mKE8gUgAOqCM__4yzEEu9HJPbx9X15lN264zkDJBRxg,12399
 mcp_vector_search/cli/commands/demo.py,sha256=MVfEkYmA2abRFwAbk-lpa6P14_SLJBHZAuHb9d6d02U,10630
-mcp_vector_search/cli/commands/index.py,sha256=DOJa2zLuL10qJ8QHpMWsTUm53vj5ERGSGAMub1-P7lI,22385
+mcp_vector_search/cli/commands/index.py,sha256=5GhJZzbzCBZYfMfZPjs9cf6RsSdgAAX2MkiTXm1i0K4,23258
 mcp_vector_search/cli/commands/init.py,sha256=2kdjtIPPeutKUXs65-6W1VQPF_BQrbV6_U3TCE7U5mw,23242
 mcp_vector_search/cli/commands/install.py,sha256=phk7Eb7UOU5IsRfJyaDPdOfdUWli9gyA4cHjhgXcNEI,24609
 mcp_vector_search/cli/commands/mcp.py,sha256=Mk4g43R9yRiJVMxsDFUsZldKqY0yi2coQmhAqIMPklo,38958
 mcp_vector_search/cli/commands/reset.py,sha256=bsIT6zjDf6gsvIkVaRaUClYzlTyNe--8t0NWkBY0ldU,13724
 mcp_vector_search/cli/commands/search.py,sha256=yyou7wO9qZ_w2oiKdyOrk2WUxvkFpc-Up8hpflxYlyw,24802
 mcp_vector_search/cli/commands/status.py,sha256=sa_0QHioCmPF5A7obqV2ls-9kmX_JYo7nq3XUe1dmrg,19630
-mcp_vector_search/cli/commands/visualize.py,sha256=tipe_QLjkZboqEz8SfIx5mjYrAenqrKsQPnXkgG7GBg,21398
+mcp_vector_search/cli/commands/visualize.py,sha256=JY1MSWW5ybpzwzbTWFeMlydyL_UgtoeQq1RUweL4Y44,28336
 mcp_vector_search/cli/commands/watch.py,sha256=2pyWRoo4fIppFnyQ4sW4IBLHmpb_IwnTjRnzHkVBPcQ,8927
 mcp_vector_search/config/__init__.py,sha256=r_qAQkU5gc0EQ2pv8EQARACe4klhrR_WRJqCb9lfGc0,54
 mcp_vector_search/config/constants.py,sha256=afXR6SvLLd8QYY4MG4s1vq-hCJiQsE5PhnE-XG9lvb4,1092
@@ -28,13 +28,13 @@ mcp_vector_search/config/settings.py,sha256=m8o8j-tvWcuzrnNL6YWbi2fFbcB3lZY1kMNi
 mcp_vector_search/core/__init__.py,sha256=bWKtKmmaFs7gG5XPCbrx77UYIVeO1FF8wIJxpj1dLNw,48
 mcp_vector_search/core/auto_indexer.py,sha256=0S4lZXaUgqEytMSA2FxQsh5hN7V1mbSLYVzEf_dslYQ,10307
 mcp_vector_search/core/connection_pool.py,sha256=Yo-gUQQbHawtuvh6OcJiAlbbvWQGQBd31QZOvs498fg,11224
-mcp_vector_search/core/database.py,sha256=wmrnlyWvNH1jr4Rx_b6OjxAeUQ-33G3Vj6v_lji2Eik,37705
+mcp_vector_search/core/database.py,sha256=HMyQ3J9DTgE8VpafoorRePtolzkX1W9wAZ3U8RvyDK4,42931
 mcp_vector_search/core/embeddings.py,sha256=wSMUNxZcuGPMxxQ1AbKqA1a3-0c6AiOqmuuI7OqTyaQ,10578
 mcp_vector_search/core/exceptions.py,sha256=3bCjT8wmrLz_0e_Tayr90049zNTKYFWZa19kl0saKz8,1597
 mcp_vector_search/core/factory.py,sha256=tM6Ft-V9buF7nn9xbRMU1ngji-BJOKt6BhtfQhFLmF4,10384
 mcp_vector_search/core/git_hooks.py,sha256=xOfPpzgKoNTwM-vbhAihUucgudBQk45bCAVR5zJOFlQ,10878
-mcp_vector_search/core/indexer.py,sha256=IpCzP50wLOttWuUI-NE0qwYq-LlbDo5lrGfVMFMzwAM,29089
-mcp_vector_search/core/models.py,sha256=f9T2vZxhOUun1nGgdhNLGQGojZewFUi9W_rvYf-IfAo,8838
+mcp_vector_search/core/indexer.py,sha256=rB4XJ2iRyk4qWuM5ykUBfbSPSdJYVNLSXNZ7qPrY9BE,29912
+mcp_vector_search/core/models.py,sha256=vWEP7JtIv9cG4eQRkUB0TW5Xo6KChzafngsj-rWnF34,9228
 mcp_vector_search/core/project.py,sha256=l81uc5B4CB8VXDbcHzF-_CagxIERDh23tH0iNqTePTs,10403
 mcp_vector_search/core/scheduler.py,sha256=PBSlu-ieDYCXOMGYY7QKv9UReFEDPHNmwnUv_xb4vxg,11761
 mcp_vector_search/core/search.py,sha256=9OC8-KwWdbw4y4QPQ-VXfz0encVHTJWYLtah3_chqG8,33682
@@ -55,10 +55,11 @@ mcp_vector_search/parsers/text.py,sha256=jvMdFspbmrrOR1GSGzf2gvBDCXz1cPN_xemoDK4
 mcp_vector_search/parsers/utils.py,sha256=10vT-GJSeDUoGSIslz8zq4RyavFiMtizCmcnn9cbQqE,8103
 mcp_vector_search/utils/__init__.py,sha256=Eq6lY-oPMfCt-GpPUbg9QbmTHuQVmTaVDBMU2183KVw,887
 mcp_vector_search/utils/gitignore.py,sha256=GiHQu9kv9PRLsWuNS8kbpXsTaBdhlsSHTu1NrZ8Ug5Y,8162
+mcp_vector_search/utils/monorepo.py,sha256=leTYx4ffN4IO0wDg7OWYfXMWMPp2Q_uEHl5WQFNk5Hs,8657
 mcp_vector_search/utils/timing.py,sha256=THC7mfbTYnUpnnDcblgQacYMzbEkfFoIShx6plmhCgg,11285
 mcp_vector_search/utils/version.py,sha256=d7fS-CLemxb8UzZ9j18zH0Y0Ud097ljKKYYOPulnGPE,1138
-mcp_vector_search-0.8.7.dist-info/METADATA,sha256=IABufdfY297Aq8rtvzJZIXHTM3J4nY8FeIPGAvAN8iQ,19120
-mcp_vector_search-0.8.7.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-mcp_vector_search-0.8.7.dist-info/entry_points.txt,sha256=y3Ygtc_JiBchNEIL-tPABo7EbzBExGAxwGdkkeP5D2I,86
-mcp_vector_search-0.8.7.dist-info/licenses/LICENSE,sha256=FqZUgGJH_tZKZLQsMCpXaLawRyLmyFKRVfMwYyEcyTs,1072
-mcp_vector_search-0.8.7.dist-info/RECORD,,
+mcp_vector_search-0.9.1.dist-info/METADATA,sha256=AjybXcW7c9FHyG5OGsQDx0tPNvxAtxeHShq78CrX42o,19120
+mcp_vector_search-0.9.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+mcp_vector_search-0.9.1.dist-info/entry_points.txt,sha256=y3Ygtc_JiBchNEIL-tPABo7EbzBExGAxwGdkkeP5D2I,86
+mcp_vector_search-0.9.1.dist-info/licenses/LICENSE,sha256=FqZUgGJH_tZKZLQsMCpXaLawRyLmyFKRVfMwYyEcyTs,1072
+mcp_vector_search-0.9.1.dist-info/RECORD,,