codegraphcontext 0.4.4__py3-none-any.whl → 0.4.6__py3-none-any.whl

codegraphcontext/cli/cli_helpers.py

@@ -721,19 +721,31 @@ def watch_helper(path: str, context: Optional[str] = None):
         # Add the directory to watch
         if is_indexed:
             console.print("[green]✓[/green] Already indexed (no initial scan needed)")
-            watcher.watch_directory(str(path_obj), perform_initial_scan=False)
+            watcher.watch_directory(
+                str(path_obj),
+                perform_initial_scan=False,
+                cgcignore_path=ctx.cgcignore_path,
+            )
         else:
             console.print("[yellow]⚠[/yellow]  Not indexed yet. Performing initial scan...")
             
             # Index the repository first (like MCP does)
             async def do_index():
-                await graph_builder.build_graph_from_path_async(path_obj, is_dependency=False)
+                await graph_builder.build_graph_from_path_async(
+                    path_obj,
+                    is_dependency=False,
+                    cgcignore_path=ctx.cgcignore_path,
+                )
             
             asyncio.run(do_index())
             console.print("[green]✓[/green] Initial scan complete")
             
             # Now start watching (without another scan)
-            watcher.watch_directory(str(path_obj), perform_initial_scan=False)
+            watcher.watch_directory(
+                str(path_obj),
+                perform_initial_scan=False,
+                cgcignore_path=ctx.cgcignore_path,
+            )
         
         console.print("[bold green]👀 Monitoring for file changes...[/bold green] (Press Ctrl+C to stop)")
         console.print("[dim]💡 Tip: Open a new terminal window to continue working[/dim]\n")

codegraphcontext/cli/config_manager.py

@@ -19,7 +19,10 @@ CONFIG_DIR = Path.home() / ".codegraphcontext"
 CONFIG_FILE = CONFIG_DIR / ".env"
 
 # Database credential keys (stored in same .env file but not managed as config)
-DATABASE_CREDENTIAL_KEYS = {"NEO4J_URI", "NEO4J_USERNAME", "NEO4J_PASSWORD", "NEO4J_DATABASE"}
+DATABASE_CREDENTIAL_KEYS = {
+    "NEO4J_URI", "NEO4J_USERNAME", "NEO4J_PASSWORD", "NEO4J_DATABASE",
+    "NORNIC_URI", "NORNIC_USERNAME", "NORNIC_PASSWORD", "NORNIC_DATABASE"
+}
 
 # Default configuration values
 DEFAULT_CONFIG = {
@@ -47,11 +50,16 @@ DEFAULT_CONFIG = {
     "SCIP_INDEXER": "false",
     "SCIP_LANGUAGES": "python,typescript,go,rust,java",
     "SKIP_EXTERNAL_RESOLUTION": "false",
+    # 0 = unlimited; any positive integer caps MCP tool response size.
+    "MAX_TOOL_RESPONSE_TOKENS": "0",
+    # JSON object mapping tool names to integer result-count limits.
+    # Example: {"find_code": 20, "analyze_code_relationships": 10, "find_dead_code": 30}
+    "TOOL_RESULT_LIMITS": "{}",
 }
 
 # Configuration key descriptions
 CONFIG_DESCRIPTIONS = {
-    "DEFAULT_DATABASE": "Default database backend (neo4j|falkordb|kuzudb)",
+    "DEFAULT_DATABASE": "Default database backend (neo4j|falkordb|kuzudb|nornic)",
     "FALKORDB_PATH": "Path to FalkorDB database file",
     "FALKORDB_SOCKET_PATH": "Path to FalkorDB Unix socket",
     "INDEX_VARIABLES": "Index variable nodes in the graph (lighter graph if false)",
@@ -74,11 +82,13 @@ CONFIG_DESCRIPTIONS = {
     "SCIP_INDEXER": "Use SCIP-based indexing for higher accuracy call/inheritance resolution (requires scip-<lang> tools installed)",
     "SCIP_LANGUAGES": "Comma-separated languages to index via SCIP when SCIP_INDEXER=true (python,typescript,go,rust,java)",
     "SKIP_EXTERNAL_RESOLUTION": "Skip resolution attempts for external library method calls (recommended for enterprise large Java/Spring codebases)",
+    "MAX_TOOL_RESPONSE_TOKENS": "Maximum tokens per MCP tool response (0 = unlimited). Truncates oversized payloads and appends a notice.",
+    "TOOL_RESULT_LIMITS": "JSON object mapping tool names to max result counts, e.g. {\"find_code\": 20, \"analyze_code_relationships\": 10}. Missing keys use built-in defaults.",
 }
 
 # Valid values for each config key
 CONFIG_VALIDATORS = {
-    "DEFAULT_DATABASE": ["neo4j", "falkordb", "falkordb-remote", "kuzudb"],
+    "DEFAULT_DATABASE": ["neo4j", "falkordb", "falkordb-remote", "kuzudb", "nornic"],
     "INDEX_VARIABLES": ["true", "false"],
     "ALLOW_DB_DELETION": ["true", "false"],
     "DEBUG_LOGS": ["true", "false"],
@@ -342,6 +352,26 @@ def validate_config_value(key: str, value: str) -> tuple[bool, Optional[str]]:
                 return False, "PARALLEL_WORKERS must be between 1 and 32"
         except ValueError:
             return False, "PARALLEL_WORKERS must be a number"
+
+    if key == "MAX_TOOL_RESPONSE_TOKENS":
+        try:
+            limit = int(value)
+            if limit < 0:
+                return False, "MAX_TOOL_RESPONSE_TOKENS must be 0 (unlimited) or a positive integer"
+        except ValueError:
+            return False, "MAX_TOOL_RESPONSE_TOKENS must be an integer (0 = unlimited)"
+
+    if key == "TOOL_RESULT_LIMITS":
+        import json as _json
+        try:
+            parsed = _json.loads(value)
+            if not isinstance(parsed, dict):
+                return False, "TOOL_RESULT_LIMITS must be a JSON object, e.g. {\"find_code\": 20}"
+            for k, v in parsed.items():
+                if not isinstance(v, int) or v < 1:
+                    return False, f"TOOL_RESULT_LIMITS: value for '{k}' must be a positive integer"
+        except _json.JSONDecodeError:
+            return False, "TOOL_RESULT_LIMITS must be valid JSON, e.g. {\"find_code\": 20, \"find_dead_code\": 30}"
     
     if key == "MAX_DEPTH":
         if value.lower() != "unlimited":

codegraphcontext/cli/main.py

@@ -854,11 +854,11 @@ def doctor():
         elif default_db == "kuzudb":
             from importlib.util import find_spec
 
-            if find_spec("kuzu") is not None:
+            if find_spec("real_ladybug") is not None:
                 console.print(f"   [green]✓[/green] KuzuDB is installed")
             else:
                 console.print(f"   [red]✗[/red] KuzuDB is not installed")
-                console.print(f"       Run: pip install kuzu")
+                console.print(f"       Run: pip install real_ladybug")
                 all_checks_passed = False
         else:
             # FalkorDB

codegraphcontext/cli/setup_wizard.py

@@ -54,15 +54,18 @@ def _save_neo4j_credentials(creds):
 
 def _generate_mcp_json(creds):
     """Generates and prints the MCP JSON configuration."""
-    cgc_path = shutil.which("cgc") or sys.executable
+    cgc_path = shutil.which("cgc")
+    pipx_path = shutil.which("pipx")
 
-    if "python" in Path(cgc_path).name:
-        # fallback to running as module if no cgc binary is found
+    if cgc_path:
         command = cgc_path
-        args = ["-m", "cgc", "mcp", "start"]
+        args = ["mcp", "start"]
+    elif pipx_path:
+        command = pipx_path
+        args = ["run", "codegraphcontext", "mcp", "start"]
     else:
-        command = cgc_path
-        args = ["mcp","start"]
+        command = sys.executable
+        args = ["-m", "codegraphcontext", "mcp", "start"]
 
     mcp_config = {
         "mcpServers": {
@@ -84,6 +87,7 @@ def _generate_mcp_json(creds):
                         "list_indexed_repositories", "delete_repository", "list_watched_paths", 
                         "unwatch_directory", "visualize_graph_query"
                     ],
+                    "disabledTools": [],
                     "disabled": False
                 },
                 "disabled": False,
@@ -424,15 +428,18 @@ def configure_mcp_client():
         env_vars[key] = value
     
     # Generate MCP configuration
-    cgc_path = shutil.which("cgc") or sys.executable
+    cgc_path = shutil.which("cgc")
+    pipx_path = shutil.which("pipx")
 
-    if "python" in Path(cgc_path).name:
-        # fallback to running as module if no cgc binary is found
-        command = cgc_path
-        args = ["-m", "cgc", "mcp", "start"]
-    else:
+    if cgc_path:
         command = cgc_path
         args = ["mcp", "start"]
+    elif pipx_path:
+        command = pipx_path
+        args = ["run", "codegraphcontext", "mcp", "start"]
+    else:
+        command = sys.executable
+        args = ["-m", "codegraphcontext", "mcp", "start"]
 
     # Create MCP config with complete env section
     mcp_config = {
@@ -451,6 +458,7 @@ def configure_mcp_client():
                         "list_indexed_repositories", "delete_repository", "list_watched_paths", 
                         "unwatch_directory", "visualize_graph_query"
                     ],
+                    "disabledTools": [],
                     "disabled": False
                 },
                 "disabled": False,

codegraphcontext/core/__init__.py

@@ -22,7 +22,7 @@ import importlib.util
 def _is_kuzudb_available() -> bool:
     """Check if KùzuDB is installed."""
     try:
-        return importlib.util.find_spec("kuzu") is not None
+        return importlib.util.find_spec("real_ladybug") is not None
     except ImportError:
         return False
 
@@ -52,7 +52,15 @@ def _is_neo4j_configured() -> bool:
         os.getenv('NEO4J_PASSWORD')
     ])
 
-def get_database_manager(db_path: Optional[str] = None) -> Union['DatabaseManager', 'FalkorDBManager', 'FalkorDBRemoteManager', 'KuzuDBManager']:
+def _is_nornic_configured() -> bool:
+    """Check if Nornic is configured with credentials."""
+    return all([
+        os.getenv('NORNIC_URI'),
+        os.getenv('NORNIC_USERNAME'),
+        os.getenv('NORNIC_PASSWORD')
+    ])
+
+def get_database_manager(db_path: Optional[str] = None) -> Union['DatabaseManager', 'FalkorDBManager', 'FalkorDBRemoteManager', 'KuzuDBManager', 'NornicDBManager']:
     """
     Factory function to get the appropriate database manager based on configuration.
 
@@ -70,7 +78,7 @@ def get_database_manager(db_path: Optional[str] = None) -> Union['DatabaseManage
         db_type = db_type.lower()
         if db_type == 'kuzudb':
             if not _is_kuzudb_available():
-                raise ValueError("Database set to 'kuzudb' but Kùzu is not installed.\nRun 'pip install kuzu'")
+                raise ValueError("Database set to 'kuzudb' but Kùzu is not installed.\nRun 'pip install real_ladybug'")
             from .database_kuzu import KuzuDBManager
             info_logger(f"Using KùzuDB (explicit) at {db_path or 'default path'}")
             return KuzuDBManager(db_path=db_path)
@@ -111,8 +119,15 @@ def get_database_manager(db_path: Optional[str] = None) -> Union['DatabaseManage
             from .database import DatabaseManager
             info_logger("Using Neo4j Server (explicit)")
             return DatabaseManager()
+
+        elif db_type == 'nornic':
+            if not _is_nornic_configured():
+                raise ValueError("Database set to 'nornic' but it is not configured.")
+            from .database_nornic import NornicDBManager
+            info_logger("Using Nornic DB (explicit)")
+            return NornicDBManager()
         else:
-            raise ValueError(f"Unknown database type: '{db_type}'. Use 'kuzudb', 'falkordb', 'falkordb-remote', or 'neo4j'.")
+            raise ValueError(f"Unknown database type: '{db_type}'. Use 'kuzudb', 'falkordb', 'falkordb-remote', 'neo4j', or 'nornic'.")
 
     # Implicit: remote FalkorDB when FALKORDB_HOST is set (explicit infra signal)
     if _is_falkordb_remote_configured():
@@ -146,8 +161,14 @@ def get_database_manager(db_path: Optional[str] = None) -> Union['DatabaseManage
         info_logger("Using Neo4j Server (auto-detected)")
         return DatabaseManager()
 
+    # Implicit: Nornic when configured
+    if _is_nornic_configured():
+        from .database_nornic import NornicDBManager
+        info_logger("Using Nornic DB (auto-detected)")
+        return NornicDBManager()
+
     error_msg = "No database backend available.\n"
-    error_msg += "Recommended: Install KùzuDB for zero-config ('pip install kuzu')\n"
+    error_msg += "Recommended: Install KùzuDB for zero-config ('pip install real_ladybug')\n"
 
     if platform.system() != "Windows":
         error_msg += "Alternative: Install FalkorDB Lite ('pip install falkordblite')\n"
@@ -161,5 +182,6 @@ from .database import DatabaseManager
 from .database_falkordb import FalkorDBManager
 from .database_falkordb_remote import FalkorDBRemoteManager
 from .database_kuzu import KuzuDBManager
+from .database_nornic import NornicDBManager
 
-__all__ = ['DatabaseManager', 'FalkorDBManager', 'FalkorDBRemoteManager', 'KuzuDBManager', 'get_database_manager']
+__all__ = ['DatabaseManager', 'FalkorDBManager', 'FalkorDBRemoteManager', 'KuzuDBManager', 'NornicDBManager', 'get_database_manager']

codegraphcontext/core/cgc_bundle.py

@@ -28,6 +28,7 @@ from datetime import datetime, date
 import subprocess
 
 from codegraphcontext.utils.debug_log import debug_log, info_logger, error_logger, warning_logger
+from codegraphcontext.utils.git_utils import get_repo_commit_hash
 
 
 class _BundleEncoder(json.JSONEncoder):
@@ -293,15 +294,9 @@ class CGCBundle:
             
             # Try to get git information if available
             if repo_path and repo_path.exists():
-                try:
-                    commit = subprocess.check_output(
-                        ['git', 'rev-parse', 'HEAD'],
-                        cwd=repo_path,
-                        stderr=subprocess.DEVNULL
-                    ).decode().strip()
+                commit = get_repo_commit_hash(repo_path)
+                if commit:
                     metadata["commit"] = commit[:8]
-                except (subprocess.CalledProcessError, FileNotFoundError):
-                    pass
 
                 try:
                     result = session.run("""

codegraphcontext/core/database_falkordb.py

@@ -356,6 +356,18 @@ class FalkorDBSessionWrapper:
         """
         Execute a Cypher query on FalkorDB.
         """
+        constraint_command = self._translate_constraint_command(query)
+        if constraint_command is not None:
+            try:
+                self.graph.execute_command(*constraint_command)
+                return FalkorDBResultWrapper(None)
+            except Exception as e:
+                error_msg = str(e).lower()
+                if "already exists" in error_msg or "already created" in error_msg:
+                    return FalkorDBResultWrapper(None)
+                error_logger(f"FalkorDB constraint failed: {constraint_command!r} Error: {e}")
+                raise
+
         # Translate Neo4j schema queries to FalkorDB syntax
         query = self._translate_schema_query(query)
         
@@ -371,6 +383,56 @@ class FalkorDBSessionWrapper:
             error_logger(f"FalkorDB query failed: {query[:100]}... Error: {e}")
             raise
 
+    def _translate_constraint_command(self, query: str):
+        """
+        Translate Neo4j-style CREATE CONSTRAINT queries to GRAPH.CONSTRAINT CREATE.
+        FalkorDB 4.16.x expects this command path instead of GRAPH.QUERY.
+        """
+        q_upper = query.upper()
+        if "CREATE CONSTRAINT" not in q_upper:
+            return None
+
+        normalized = re.sub(r"\s+IF NOT EXISTS", "", query, flags=re.IGNORECASE)
+        normalized = re.sub(r"\s+", " ", normalized).strip()
+
+        entity_match = re.search(r"FOR\s*\((\w+):([^)]+)\)", normalized, flags=re.IGNORECASE)
+        if not entity_match:
+            return None
+        entity_type = "NODE"
+        label = entity_match.group(2).strip()
+
+        composite_match = re.search(
+            r"REQUIRE\s*\(([^)]+)\)\s*IS\s+UNIQUE",
+            normalized,
+            flags=re.IGNORECASE,
+        )
+        single_match = re.search(
+            r"REQUIRE\s+\w+\.([A-Za-z_][A-Za-z0-9_]*)\s+IS\s+UNIQUE",
+            normalized,
+            flags=re.IGNORECASE,
+        )
+
+        if composite_match:
+            props = [part.split(".")[-1].strip() for part in composite_match.group(1).split(",") if part.strip()]
+            constraint_type = "UNIQUE"
+        elif single_match:
+            props = [single_match.group(1).strip()]
+            constraint_type = "UNIQUE"
+        else:
+            return None
+
+        return [
+            "GRAPH.CONSTRAINT",
+            "CREATE",
+            self.graph.name,
+            constraint_type,
+            entity_type,
+            label,
+            "PROPERTIES",
+            len(props),
+            *props,
+        ]
+
     def _translate_schema_query(self, query: str) -> str:
         """Translate Neo4j schema queries to FalkorDB/RedisGraph syntax."""
         q_upper = query.upper()
@@ -379,26 +441,9 @@ class FalkorDBSessionWrapper:
         if "CREATE FULLTEXT INDEX" in q_upper:
             return "RETURN 1"
             
-        # Handle Constraints
+        # Handle Constraints through GRAPH.CONSTRAINT in run()
         if "CREATE CONSTRAINT" in q_upper:
-            # Remove "IF NOT EXISTS"
-            query = re.sub(r'\s+IF NOT EXISTS', '', query, flags=re.IGNORECASE)
-            
-            # Handle composite keys: (n.p1, n.p2) -> downgrade to INDEX
-            if "," in query:
-                match_node = re.search(r'FOR\s+(\([^)]+\))', query, flags=re.IGNORECASE)
-                match_props = re.search(r'REQUIRE\s+(\([^)]+\))\s+IS UNIQUE', query, flags=re.IGNORECASE)
-                
-                if match_node and match_props:
-                    return f"CREATE INDEX FOR {match_node.group(1)} ON {match_props.group(1)}"
-
-            # Handle simple uniqueness: CREATE CONSTRAINT name FOR (n:Label) REQUIRE n.prop IS UNIQUE
-            # TO: CREATE CONSTRAINT ON (n:Label) ASSERT n.prop IS UNIQUE
-            
-            # Remove constraint name
-            query = re.sub(r'CREATE CONSTRAINT\s+\w+\s+', 'CREATE CONSTRAINT ', query, flags=re.IGNORECASE)
-            query = re.sub(r'\s+FOR\s+', ' ON ', query, flags=re.IGNORECASE)
-            query = re.sub(r'\s+REQUIRE\s+', ' ASSERT ', query, flags=re.IGNORECASE)
+            return "RETURN 1"
             
         # Handle Regular Indexes
         elif "CREATE INDEX" in q_upper:

codegraphcontext/core/database_kuzu.py

@@ -66,7 +66,7 @@ class KuzuDBManager:
         if self._conn is None:
             with self._lock:
                 if self._conn is None:
-                    import kuzu
+                    import real_ladybug as kuzu
                     max_retries = 5
                     for attempt in range(max_retries):
                         try:
@@ -77,7 +77,7 @@ class KuzuDBManager:
                             info_logger("KùzuDB connection established and schema verified")
                             break
                         except ImportError:
-                            error_logger("KùzuDB is not installed. Run 'pip install kuzu'")
+                            error_logger("KùzuDB is not installed. Run 'pip install real_ladybug'")
                             raise ValueError("KùzuDB missing.")
                         except Exception as e:
                             if "lock" in str(e).lower() and attempt < max_retries - 1:
@@ -99,7 +99,7 @@ class KuzuDBManager:
         # but we can wrap in try-except or check metadata.
         
         node_tables = [
-            ("Repository", "path STRING, name STRING, is_dependency BOOLEAN, PRIMARY KEY (path)"),
+            ("Repository", "path STRING, name STRING, is_dependency BOOLEAN, indexed_at STRING, commit_hash STRING, PRIMARY KEY (path)"),
             ("File", "path STRING, name STRING, relative_path STRING, is_dependency BOOLEAN, PRIMARY KEY (path)"),
             ("Directory", "path STRING, name STRING, PRIMARY KEY (path)"),
             ("Module", "name STRING, lang STRING, full_import_name STRING, PRIMARY KEY (name)"),
@@ -156,6 +156,29 @@ class KuzuDBManager:
                     warning_logger(f"Kuzu Schema Rel Error ({table_name}): {e}")
                     debug_log(f"Kuzu Schema Rel Error ({table_name}): {e}")
 
+        self._run_schema_migrations()
+
+    def _run_schema_migrations(self):
+        """Add columns introduced after older local Kùzu databases were created."""
+        migrations = [
+            ("Module", "full_import_name", "STRING"),
+            ("IMPORTS", "full_import_name", "STRING"),
+            ("IMPORTS", "imported_name", "STRING"),
+            # Freshness properties added to Repository in 0.4.6
+            ("Repository", "indexed_at", "STRING"),
+            ("Repository", "commit_hash", "STRING"),
+        ]
+
+        for table_name, column_name, column_type in migrations:
+            try:
+                self._conn.execute(f"ALTER TABLE `{table_name}` ADD {column_name} {column_type}")
+            except Exception as e:
+                err = str(e).lower()
+                if "already exists" in err or "duplicate" in err or "already has property" in err:
+                    continue
+                warning_logger(f"Kuzu Schema Migration Error ({table_name}.{column_name}): {e}")
+                debug_log(f"Kuzu Schema Migration Error ({table_name}.{column_name}): {e}")
+
     def close_driver(self):
         """Closes the connection."""
         if self._conn is not None:
@@ -188,10 +211,10 @@ class KuzuDBManager:
     @staticmethod
     def test_connection(db_path: str = None) -> Tuple[bool, Optional[str]]:
         try:
-            import kuzu
+            import real_ladybug as kuzu
             return True, None
         except ImportError:
-            return False, "KùzuDB is not installed. Run 'pip install kuzu'"
+            return False, "KùzuDB is not installed. Run 'pip install real_ladybug'"
 
 class KuzuDriverWrapper:
     def __init__(self, conn):
@@ -257,6 +280,32 @@ class KuzuSessionWrapper:
             err_str = str(e).lower()
             if "already exists" in err_str:
                 return KuzuResultWrapper(None)
+            
+            # Fallback for KuzuDB UNWIND bug (unordered_map::at)
+            if "unordered_map::at" in err_str and "UNWIND" in query:
+                unwind_m = re.search(r'UNWIND\s+\$(\w+)\s+AS\s+(\w+)', query)
+                if unwind_m:
+                    batch_param = unwind_m.group(1)
+                    row_var = unwind_m.group(2)
+                    batch_data = parameters.get(batch_param)
+                    if isinstance(batch_data, list):
+                        loop_query = re.sub(r'UNWIND\s+\$\w+\s+AS\s+\w+', '', query, count=1)
+                        # Find all row.prop usages and replace with $row_prop
+                        props_used = set(re.findall(rf'{row_var}\.(\w+)', loop_query))
+                        for p in props_used:
+                            loop_query = loop_query.replace(f"{row_var}.{p}", f"${row_var}_{p}")
+                        
+                        last_result = None
+                        for item in batch_data:
+                            loop_params = parameters.copy()
+                            loop_params.pop(batch_param, None)
+                            for p in props_used:
+                                loop_params[f"{row_var}_{p}"] = item.get(p)
+                            if "uid" in item:
+                                loop_params[f"{row_var}_uid"] = item["uid"]
+                            last_result = self.run(loop_query, **loop_params)
+                        return last_result or KuzuResultWrapper(None)
+
             error_logger(f"Kuzu Query failed: {query[:100]}... Error: {e}")
             debug_log(f"Kuzu Query failed: {query[:100]}... Error: {e}")
             raise