codegraphcontext 0.1.34__tar.gz → 0.1.35__tar.gz

{codegraphcontext-0.1.34/src/codegraphcontext.egg-info → codegraphcontext-0.1.35}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codegraphcontext
-Version: 0.1.34
+Version: 0.1.35
 Summary: An MCP server that indexes local code into a graph database to provide context to AI assistants.
 Author-email: Shashank Shekhar Singh <shashankshekharsingh1205@gmail.com>
 License: MIT License
@@ -91,7 +91,7 @@ A powerful **MCP server** and **CLI toolkit** that indexes local code into a gra
 ![Using the MCP server](https://github.com/CodeGraphContext/CodeGraphContext/blob/main/images/Usecase.gif)
 
 ## Project Details
-- **Version:** 0.1.34
+- **Version:** 0.1.35
 - **Authors:** Shashank Shekhar Singh <shashankshekharsingh1205@gmail.com>
 - **License:** MIT License (See [LICENSE](LICENSE) for details)
 - **Website:** [CodeGraphContext](http://codegraphcontext.vercel.app/)

{codegraphcontext-0.1.34 → codegraphcontext-0.1.35}/README.md

@@ -29,7 +29,7 @@ A powerful **MCP server** and **CLI toolkit** that indexes local code into a gra
 ![Using the MCP server](https://github.com/CodeGraphContext/CodeGraphContext/blob/main/images/Usecase.gif)
 
 ## Project Details
-- **Version:** 0.1.34
+- **Version:** 0.1.35
 - **Authors:** Shashank Shekhar Singh <shashankshekharsingh1205@gmail.com>
 - **License:** MIT License (See [LICENSE](LICENSE) for details)
 - **Website:** [CodeGraphContext](http://codegraphcontext.vercel.app/)

{codegraphcontext-0.1.34 → codegraphcontext-0.1.35}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "codegraphcontext"
-version = "0.1.34"
+version = "0.1.35"
 description = "An MCP server that indexes local code into a graph database to provide context to AI assistants."
 authors = [{ name = "Shashank Shekhar Singh", email = "shashankshekharsingh1205@gmail.com" }]
 readme = "README.md"

{codegraphcontext-0.1.34 → codegraphcontext-0.1.35}/src/codegraphcontext/cli/cli_helpers.py

@@ -572,28 +572,25 @@ def stats_helper(path: str = None):
             console.print("[cyan]📊 Overall Database Statistics[/cyan]\n")
             
             with db_manager.get_driver().session() as session:
-                # Get overall counts
+                # Get overall counts using separate queries to avoid empty results
+                # when some node types don't exist
                 stats_query = """
                 MATCH (r:Repository)
-                WITH count(r) as repo_count
-                MATCH (f:File)
-                WITH repo_count, count(f) as file_count
-                MATCH (func:Function)
-                WITH repo_count, file_count, count(func) as function_count
-                MATCH (cls:Class)
-                WITH repo_count, file_count, function_count, count(cls) as class_count
-                MATCH (m:Module)
+                OPTIONAL MATCH (f:File)
+                OPTIONAL MATCH (func:Function)
+                OPTIONAL MATCH (cls:Class)
+                OPTIONAL MATCH (m:Module)
                 RETURN 
-                    repo_count,
-                    file_count,
-                    function_count,
-                    class_count,
-                    count(m) as module_count
+                    count(DISTINCT r) as repo_count,
+                    count(DISTINCT f) as file_count,
+                    count(DISTINCT func) as function_count,
+                    count(DISTINCT cls) as class_count,
+                    count(DISTINCT m) as module_count
                 """
                 result = session.run(stats_query)
                 record = result.single()
                 
-                if record:
+                if record and record["repo_count"] > 0:
                     table = Table(show_header=True, header_style="bold magenta")
                     table.add_column("Metric", style="cyan")
                     table.add_column("Count", style="green", justify="right")

{codegraphcontext-0.1.34 → codegraphcontext-0.1.35}/src/codegraphcontext/cli/main.py

@@ -44,9 +44,11 @@ from .cli_helpers import (
     list_watching_helper,
 )
 
-# Set the log level for the noisy neo4j and asyncio logger to WARNING to keep the output clean.
+# Set the log level for the noisy neo4j, asyncio, and urllib3 loggers to WARNING to keep the output clean.
 logging.getLogger("neo4j").setLevel(logging.WARNING)
 logging.getLogger("asyncio").setLevel(logging.WARNING)
+logging.getLogger("urllib3").setLevel(logging.WARNING)
+
 
 # Import visualization module
 from .visualizer import (
@@ -552,19 +554,22 @@ app.add_typer(registry_app, name="registry")
 
 @registry_app.command("list")
 def registry_list(
-    verbose: bool = typer.Option(False, "--verbose", "-v", help="Show detailed information including download URLs")
+    verbose: bool = typer.Option(False, "--verbose", "-v", help="Show detailed information including download URLs"),
+    unique: bool = typer.Option(False, "--unique", "-u", help="Show only one version per package (most recent)")
 ):
     """
     List all available bundles in the registry.
     
     Shows bundles from both weekly pre-indexed releases and on-demand generations.
+    By default, shows all versions. Use --unique to see only the most recent version per package.
     
     Examples:
         cgc registry list
         cgc registry list --verbose
+        cgc registry list --unique
     """
     from .registry_commands import list_bundles
-    list_bundles(verbose=verbose)
+    list_bundles(verbose=verbose, unique=unique)
 
 @registry_app.command("search")
 def registry_search(

{codegraphcontext-0.1.34 → codegraphcontext-0.1.35}/src/codegraphcontext/cli/registry_commands.py

@@ -25,6 +25,7 @@ def fetch_available_bundles() -> List[Dict[str, Any]]:
     """
     Fetch all available bundles from GitHub Releases.
     Returns a list of bundle dictionaries with metadata.
+    Preserves all versions - no deduplication.
     """
     all_bundles = []
     
@@ -37,6 +38,10 @@ def fetch_available_bundles() -> List[Dict[str, Any]]:
                 if manifest.get('bundles'):
                     for bundle in manifest['bundles']:
                         bundle['source'] = 'on-demand'
+                        # Ensure bundle has a full_name field (with version info)
+                        if 'bundle_name' in bundle:
+                            # Extract full name without .cgc extension
+                            bundle['full_name'] = bundle['bundle_name'].replace('.cgc', '')
                         all_bundles.append(bundle)
         except Exception as e:
             console.print(f"[dim]Note: Could not fetch on-demand bundles: {e}[/dim]")
@@ -56,10 +61,14 @@ def fetch_available_bundles() -> List[Dict[str, Any]]:
                     
                     for asset in latest_weekly.get('assets', []):
                         if asset['name'].endswith('.cgc'):
+                            # Full bundle name without extension
+                            full_name = asset['name'].replace('.cgc', '')
+                            
                             # Parse bundle name
-                            name_parts = asset['name'].replace('.cgc', '').split('-')
+                            name_parts = full_name.split('-')
                             bundle = {
-                                'name': name_parts[0],
+                                'name': name_parts[0],  # Base package name
+                                'full_name': full_name,  # Complete name with version
                                 'repo': f"{name_parts[0]}/{name_parts[0]}",  # Simplified
                                 'bundle_name': asset['name'],
                                 'version': name_parts[1] if len(name_parts) > 1 else 'latest',
@@ -73,32 +82,60 @@ def fetch_available_bundles() -> List[Dict[str, Any]]:
         except Exception as e:
             console.print(f"[dim]Note: Could not fetch weekly bundles: {e}[/dim]")
         
-        # Remove duplicates (prefer on-demand over weekly)
-        unique_bundles = {}
+        # Normalize all bundles to have required fields
         for bundle in all_bundles:
-            # Extract name from repo field (e.g., "pallets/flask" -> "flask")
-            repo = bundle.get('repo', '')
-            if '/' in repo:
-                name = repo.split('/')[-1]  # Get the last part after /
-            else:
-                name = bundle.get('name', repo.split('/')[-1] if '/' in repo else 'unknown')
+            # Ensure 'name' field exists (base package name)
+            if 'name' not in bundle:
+                repo = bundle.get('repo', '')
+                if '/' in repo:
+                    bundle['name'] = repo.split('/')[-1]
+                else:
+                    # Extract from full_name or bundle_name
+                    full_name = bundle.get('full_name', bundle.get('bundle_name', 'unknown'))
+                    bundle['name'] = full_name.split('-')[0]
             
-            # Add name to bundle if not present
-            if 'name' not in bundle or bundle['name'] == 'unknown':
-                bundle['name'] = name
-            
-            if name not in unique_bundles or bundle.get('source') == 'on-demand':
-                unique_bundles[name] = bundle
+            # Ensure 'full_name' exists
+            if 'full_name' not in bundle:
+                bundle['full_name'] = bundle.get('bundle_name', bundle.get('name', 'unknown')).replace('.cgc', '')
         
-        return list(unique_bundles.values())
+        # NO DEDUPLICATION - Keep all versions
+        return all_bundles
     
     except Exception as e:
         console.print(f"[bold red]Error fetching bundles: {e}[/bold red]")
         return []
 
 
-def list_bundles(verbose: bool = False):
-    """Display all available bundles in a table."""
+def _get_base_package_name(bundle_name: str) -> str:
+    """
+    Extract base package name from full bundle name.
+    
+    Examples:
+        'python-bitcoin-utils-main-61d1969' -> 'python-bitcoin-utils'
+        'flask-main-abc123' -> 'flask'
+        'requests' -> 'requests'
+    """
+    # Remove .cgc extension if present
+    name = bundle_name.replace('.cgc', '')
+    
+    # Split by hyphen and take the first part
+    # This assumes package names don't contain hyphens (may need refinement)
+    parts = name.split('-')
+    
+    # For multi-word package names like 'python-bitcoin-utils',
+    # we need smarter logic. For now, take first part.
+    # TODO: Improve this with a known package list or better heuristics
+    return parts[0]
+
+
+def list_bundles(verbose: bool = False, unique: bool = False):
+    """
+    Display all available bundles in a table.
+    
+    Args:
+        verbose: Show additional details like download URLs
+        unique: Show only one version per package (most recent)
+    """
     console.print("[cyan]Fetching available bundles...[/cyan]")
     
     bundles = fetch_available_bundles()
@@ -108,9 +145,25 @@ def list_bundles(verbose: bool = False):
         console.print("[dim]The registry may be empty or unreachable.[/dim]")
         return
     
+    # If unique flag is set, keep only the most recent version per package
+    if unique:
+        unique_bundles = {}
+        for bundle in bundles:
+            base_name = bundle.get('name', 'unknown')
+            # Keep the one with the most recent timestamp
+            if base_name not in unique_bundles:
+                unique_bundles[base_name] = bundle
+            else:
+                # Compare timestamps (generated_at field)
+                current_time = bundle.get('generated_at', '')
+                existing_time = unique_bundles[base_name].get('generated_at', '')
+                if current_time > existing_time:
+                    unique_bundles[base_name] = bundle
+        bundles = list(unique_bundles.values())
+    
     # Create table
     table = Table(show_header=True, header_style="bold magenta", title="Available Bundles")
-    table.add_column("Name", style="cyan", no_wrap=True)
+    table.add_column("Bundle Name", style="cyan", no_wrap=True)
     table.add_column("Repository", style="dim")
     table.add_column("Version", style="green")
     table.add_column("Size", justify="right")
@@ -119,11 +172,12 @@ def list_bundles(verbose: bool = False):
     if verbose:
         table.add_column("Download URL", style="blue", no_wrap=False)
     
-    # Sort by name
-    bundles.sort(key=lambda b: b.get('name', ''))
+    # Sort by full_name to group versions together
+    bundles.sort(key=lambda b: (b.get('name', ''), b.get('full_name', '')))
     
     for bundle in bundles:
-        name = bundle.get('name', 'unknown')
+        # Use full_name for display (includes version info)
+        display_name = bundle.get('full_name', bundle.get('name', 'unknown'))
         repo = bundle.get('repo', 'unknown')
         version = bundle.get('version', bundle.get('tag', 'latest'))
         size = bundle.get('size', 'unknown')
@@ -131,12 +185,16 @@ def list_bundles(verbose: bool = False):
         
         if verbose:
             download_url = bundle.get('download_url', 'N/A')
-            table.add_row(name, repo, version, size, source, download_url)
+            table.add_row(display_name, repo, version, size, source, download_url)
         else:
-            table.add_row(name, repo, version, size, source)
+            table.add_row(display_name, repo, version, size, source)
     
     console.print(table)
     console.print(f"\n[dim]Total bundles: {len(bundles)}[/dim]")
+    if unique:
+        console.print("[dim]Showing only most recent version per package. Use without --unique to see all versions.[/dim]")
+    else:
+        console.print("[dim]Use --unique to show only one version per package[/dim]")
     console.print("[dim]Use 'cgc registry download <name>' to download a bundle[/dim]")
 
 
@@ -183,7 +241,12 @@ def search_bundles(query: str):
 
 
 def download_bundle(name: str, output_dir: Optional[str] = None, auto_load: bool = False):
-    """Download a bundle from the registry."""
+    """
+    Download a bundle from the registry.
+    
+    Supports both full names (e.g., 'python-bitcoin-utils-main-61d1969')
+    and base names (e.g., 'python-bitcoin-utils' - picks most recent version).
+    """
     console.print(f"[cyan]Looking for bundle '{name}'...[/cyan]")
     
     bundles = fetch_available_bundles()
@@ -192,16 +255,59 @@ def download_bundle(name: str, output_dir: Optional[str] = None, auto_load: bool
         console.print("[bold red]Could not fetch bundle registry.[/bold red]")
         raise typer.Exit(code=1)
     
-    # Find the bundle
+    # Strategy 1: Try exact match on full_name (with version)
     bundle = None
     for b in bundles:
-        if b.get('name', '').lower() == name.lower():
+        if b.get('full_name', '').lower() == name.lower():
             bundle = b
+            console.print(f"[dim]Found exact match: {b.get('full_name')}[/dim]")
             break
     
+    # Strategy 2: If no exact match, try matching base package name
+    # and pick the most recent version
     if not bundle:
+        matching_bundles = []
+        for b in bundles:
+            if b.get('name', '').lower() == name.lower():
+                matching_bundles.append(b)
+        
+        if matching_bundles:
+            # Sort by timestamp and pick the most recent
+            matching_bundles.sort(key=lambda x: x.get('generated_at', ''), reverse=True)
+            bundle = matching_bundles[0]
+            
+            console.print(f"[yellow]Multiple versions found for '{name}'. Using most recent:[/yellow]")
+            console.print(f"[cyan]  → {bundle.get('full_name')}[/cyan]")
+            
+            if len(matching_bundles) > 1:
+                console.print(f"\n[dim]Other available versions:[/dim]")
+                for b in matching_bundles[1:4]:  # Show up to 3 alternatives
+                    console.print(f"[dim]  • {b.get('full_name')}[/dim]")
+                if len(matching_bundles) > 4:
+                    console.print(f"[dim]  ... and {len(matching_bundles) - 4} more[/dim]")
+                console.print()
+    
+    # Strategy 3: No match found - show suggestions
+    if not bundle:
+        # Find bundles with similar base names
+        suggestions = []
+        name_lower = name.lower()
+        for b in bundles:
+            base_name = b.get('name', '').lower()
+            full_name = b.get('full_name', '').lower()
+            
+            # Fuzzy matching: check if search term is in base or full name
+            if name_lower in base_name or name_lower in full_name:
+                suggestions.append(b.get('full_name', b.get('name', 'unknown')))
+        
         console.print(f"[bold red]Bundle '{name}' not found in registry.[/bold red]")
-        console.print("[dim]Use 'cgc registry list' to see available bundles[/dim]")
+        
+        if suggestions:
+            console.print("\n[yellow]Did you mean one of these?[/yellow]")
+            for suggestion in suggestions[:5]:  # Show top 5
+                console.print(f"  • {suggestion}")
+        
+        console.print("\n[dim]Use 'cgc registry list' to see all available bundles[/dim]")
         raise typer.Exit(code=1)
     
     # Get download URL

{codegraphcontext-0.1.34 → codegraphcontext-0.1.35}/src/codegraphcontext/core/cgc_bundle.py

@@ -44,6 +44,21 @@ class CGCBundle:
         """
         self.db_manager = db_manager
     
+    def _get_id_function(self) -> str:
+        """
+        Get the appropriate ID function based on the database backend.
+        
+        Returns:
+            str: 'elementId' for Neo4j, 'id' for FalkorDB
+        """
+        # Check if we're using Neo4j or FalkorDB
+        backend = self.db_manager.get_backend_type()
+        if backend == 'neo4j':
+            return 'elementId'
+        else:  # FalkorDB or other backends
+            return 'id'
+
+    
     def export_to_bundle(
         self,
         output_path: Path,
@@ -622,13 +637,16 @@ cgc import <bundle-file>.cgc
     
     def _import_node_batch(self, session, batch: List[Tuple], id_mapping: Dict) -> int:
         """Import a batch of nodes."""
+        # Detect database backend to use appropriate ID function
+        id_function = self._get_id_function()
+        
         for labels, properties, old_id in batch:
             if not labels:
                 continue
             
             # Create node with labels
             label_str = ':'.join(labels)
-            query = f"CREATE (n:{label_str}) SET n = $props RETURN elementId(n) as new_id"
+            query = f"CREATE (n:{label_str}) SET n = $props RETURN {id_function}(n) as new_id"
             
             result = session.run(query, props=properties)
             record = result.single()
@@ -663,6 +681,8 @@ cgc import <bundle-file>.cgc
     def _import_edge_batch(self, session, batch: List[Dict]) -> int:
         """Import a batch of edges."""
         id_mapping = getattr(self, '_id_mapping', {})
+        # Detect database backend to use appropriate ID function
+        id_function = self._get_id_function()
         
         for edge in batch:
             old_from = edge.get('from')
@@ -681,7 +701,7 @@ cgc import <bundle-file>.cgc
             # Create relationship
             query = f"""
                 MATCH (a), (b)
-                WHERE elementId(a) = $from_id AND elementId(b) = $to_id
+                WHERE {id_function}(a) = $from_id AND {id_function}(b) = $to_id
                 CREATE (a)-[r:{rel_type}]->(b)
                 SET r = $props
             """
@@ -689,3 +709,4 @@ cgc import <bundle-file>.cgc
             session.run(query, from_id=new_from, to_id=new_to, props=properties)
         
         return len(batch)
+

{codegraphcontext-0.1.34 → codegraphcontext-0.1.35}/src/codegraphcontext/core/database.py

@@ -121,6 +121,11 @@ class DatabaseManager:
             return True
         except Exception:
             return False
+    
+    def get_backend_type(self) -> str:
+        """Returns the database backend type."""
+        return 'neo4j'
+
 
     @staticmethod
     def validate_config(uri: str, username: str, password: str) -> Tuple[bool, Optional[str]]:

{codegraphcontext-0.1.34 → codegraphcontext-0.1.35}/src/codegraphcontext/core/database_falkordb.py

@@ -225,6 +225,11 @@ class FalkorDBManager:
             return True
         except Exception:
             return False
+    
+    def get_backend_type(self) -> str:
+        """Returns the database backend type."""
+        return 'falkordb'
+
 
     @staticmethod
     def validate_config(db_path: str = None) -> Tuple[bool, Optional[str]]:

{codegraphcontext-0.1.34 → codegraphcontext-0.1.35/src/codegraphcontext.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codegraphcontext
-Version: 0.1.34
+Version: 0.1.35
 Summary: An MCP server that indexes local code into a graph database to provide context to AI assistants.
 Author-email: Shashank Shekhar Singh <shashankshekharsingh1205@gmail.com>
 License: MIT License
@@ -91,7 +91,7 @@ A powerful **MCP server** and **CLI toolkit** that indexes local code into a gra
 ![Using the MCP server](https://github.com/CodeGraphContext/CodeGraphContext/blob/main/images/Usecase.gif)
 
 ## Project Details
-- **Version:** 0.1.34
+- **Version:** 0.1.35
 - **Authors:** Shashank Shekhar Singh <shashankshekharsingh1205@gmail.com>
 - **License:** MIT License (See [LICENSE](LICENSE) for details)
 - **Website:** [CodeGraphContext](http://codegraphcontext.vercel.app/)