codegraphcontext-rust 0.5.5__cp311-cp311-win_amd64.whl

codegraphcontext/tools/system.py

@@ -0,0 +1,133 @@
+# src/codegraphcontext/tools/system.py
+import logging
+from dataclasses import asdict
+from typing import Any, Dict
+from datetime import datetime, timedelta
+
+from neo4j.exceptions import CypherSyntaxError
+
+from ..core.database import DatabaseManager
+from ..core.jobs import JobManager, JobStatus
+from ..utils.debug_log import debug_log
+
+logger = logging.getLogger(__name__)
+
+
+class SystemTools:
+    """Handles system-level tools like job management and direct DB queries."""
+
+    def __init__(self, db_manager: DatabaseManager, job_manager: JobManager):
+        self.db_manager = db_manager
+        self.job_manager = job_manager
+
+    def check_job_status_tool(self, job_id: str) -> Dict[str, Any]:
+        """Tool to check job status"""
+        try:
+            job = self.job_manager.get_job(job_id)
+            if not job:
+                return {"error": f"Job {job_id} not found"}
+            
+            job_dict = asdict(job)
+            
+            if job.status == JobStatus.RUNNING:
+                if job.estimated_time_remaining:
+                    remaining = job.estimated_time_remaining
+                    job_dict["estimated_time_remaining_human"] = (
+                        f"{int(remaining // 60)}m {int(remaining % 60)}s" 
+                        if remaining >= 60 else f"{int(remaining)}s"
+                    )
+                
+                if job.start_time:
+                    elapsed = (datetime.now() - job.start_time).total_seconds()
+                    job_dict["elapsed_time_human"] = (
+                        f"{int(elapsed // 60)}m {int(elapsed % 60)}s" 
+                        if elapsed >= 60 else f"{int(elapsed)}s"
+                    )
+            
+            elif job.status == JobStatus.COMPLETED and job.start_time and job.end_time:
+                duration = (job.end_time - job.start_time).total_seconds()
+                job_dict["actual_duration_human"] = (
+                    f"{int(duration // 60)}m {int(duration % 60)}s" 
+                    if duration >= 60 else f"{int(duration)}s"
+                )
+            
+            job_dict["start_time"] = job.start_time.strftime("%Y-%m-%d %H:%M:%S")
+            if job.end_time:
+                job_dict["end_time"] = job.end_time.strftime("%Y-%m-%d %H:%M:%S")
+            
+            job_dict["status"] = job.status.value
+            return {"success": True, "job": job_dict}
+        except Exception as e:
+            return {"error": f"Failed to check job status: {str(e)}"}
+
+    def list_jobs_tool(self) -> Dict[str, Any]:
+        """Tool to list all jobs"""
+        try:
+            jobs = self.job_manager.list_jobs()
+            jobs_data = []
+            for job in sorted(jobs, key=lambda j: j.start_time, reverse=True):
+                job_dict = asdict(job)
+                job_dict["status"] = job.status.value
+                job_dict["start_time"] = job.start_time.isoformat()
+                if job.end_time:
+                    job_dict["end_time"] = job.end_time.isoformat()
+                jobs_data.append(job_dict)
+            return {"success": True, "jobs": jobs_data, "total_jobs": len(jobs_data)}
+        except Exception as e:
+            return {"error": f"Failed to list jobs: {str(e)}"}
+
+    def execute_cypher_query_tool(self, cypher_query: str) -> Dict[str, Any]:
+        """Tool to execute a read-only Cypher query."""
+        if not cypher_query:
+            return {"error": "Cypher query cannot be empty."}
+
+        import re as _re
+        forbidden_keywords = ['CREATE', 'MERGE', 'DELETE', 'SET', 'REMOVE', 'DROP', 'CALL apoc']
+        string_literal_pattern = r'"(?:\\.|[^"\\])*"|\'(?:\\.|[^\'\\])*\''
+        query_without_strings = _re.sub(string_literal_pattern, '', cypher_query)
+        for keyword in forbidden_keywords:
+            if _re.search(r'\b' + keyword + r'\b', query_without_strings, _re.IGNORECASE):
+                return {"error": "This tool only supports read-only queries. Prohibited keywords like CREATE, MERGE, DELETE, SET, etc., are not allowed."}
+
+        try:
+            with self.db_manager.get_driver().session() as session:
+                result = session.run(cypher_query)
+                records = [record.data() for record in result]
+                return {
+                    "success": True,
+                    "query": cypher_query,
+                    "record_count": len(records),
+                    "results": records
+                }
+        except CypherSyntaxError as e:
+            return {"error": "Cypher syntax error.", "details": str(e)}
+        except Exception as e:
+            return {"error": "An unexpected error occurred.", "details": str(e)}
+
+    def find_dead_code_tool(self) -> Dict[str, Any]:
+        """Finds potentially unused functions (dead code)."""
+        # This logic was moved from CodeFinder to be a system diagnostic tool
+        try:
+            with self.db_manager.get_driver().session() as session:
+                result = session.run("""
+                    MATCH (func:Function)
+                    WHERE func.is_dependency = false
+                      AND NOT func.name STARTS WITH '_'
+                      AND NOT func.name IN ['main', 'setup', 'run']
+                    OPTIONAL MATCH (caller:Function)-[:CALLS]->(func)
+                    WHERE caller.is_dependency = false
+                    WITH func, count(caller) as caller_count
+                    WHERE caller_count = 0
+                    RETURN func.name as function_name, func.path as path, func.line_number as line_number
+                    ORDER BY func.path, func.line_number
+                    LIMIT 50
+                """)
+                return {
+                    "success": True,
+                    "results": {
+                        "potentially_unused_functions": [dict(record) for record in result],
+                        "note": "These functions might be entry points or called dynamically."
+                    }
+                }
+        except Exception as e:
+            return {"error": f"Failed to find dead code: {str(e)}"}

codegraphcontext/tools/tree_sitter_parser.py

@@ -0,0 +1,103 @@
+"""Tree-sitter parser dispatch by language name."""
+
+from pathlib import Path
+from typing import Dict, Optional
+
+from tree_sitter import Language, Parser
+
+from ..utils.tree_sitter_manager import get_tree_sitter_manager
+
+
+class TreeSitterParser:
+    """A generic parser wrapper for a specific language using tree-sitter."""
+
+    def __init__(self, language_name: str):
+        self.language_name = language_name
+        self.ts_manager = get_tree_sitter_manager()
+
+        self.language: Language = self.ts_manager.get_language_safe(language_name)
+        self.parser = Parser(self.language)
+
+        self.language_specific_parser = None
+        if self.language_name == "python":
+            from .languages.python import PythonTreeSitterParser
+
+            self.language_specific_parser = PythonTreeSitterParser(self)
+        elif self.language_name == "javascript":
+            from .languages.javascript import JavascriptTreeSitterParser
+
+            self.language_specific_parser = JavascriptTreeSitterParser(self)
+        elif self.language_name == "go":
+            from .languages.go import GoTreeSitterParser
+
+            self.language_specific_parser = GoTreeSitterParser(self)
+        elif self.language_name == "typescript":
+            from .languages.typescript import TypescriptTreeSitterParser
+
+            self.language_specific_parser = TypescriptTreeSitterParser(self)
+        elif self.language_name == "tsx":
+            from .languages.typescriptjsx import TypescriptJSXTreeSitterParser
+
+            self.language_specific_parser = TypescriptJSXTreeSitterParser(self)
+        elif self.language_name == "cpp":
+            from .languages.cpp import CppTreeSitterParser
+
+            self.language_specific_parser = CppTreeSitterParser(self)
+        elif self.language_name == "rust":
+            from .languages.rust import RustTreeSitterParser
+
+            self.language_specific_parser = RustTreeSitterParser(self)
+        elif self.language_name == "c":
+            from .languages.c import CTreeSitterParser
+
+            self.language_specific_parser = CTreeSitterParser(self)
+        elif self.language_name == "java":
+            from .languages.java import JavaTreeSitterParser
+
+            self.language_specific_parser = JavaTreeSitterParser(self)
+        elif self.language_name == "ruby":
+            from .languages.ruby import RubyTreeSitterParser
+
+            self.language_specific_parser = RubyTreeSitterParser(self)
+        elif self.language_name == "c_sharp":
+            from .languages.csharp import CSharpTreeSitterParser
+
+            self.language_specific_parser = CSharpTreeSitterParser(self)
+        elif self.language_name == "php":
+            from .languages.php import PhpTreeSitterParser
+
+            self.language_specific_parser = PhpTreeSitterParser(self)
+        elif self.language_name == "kotlin":
+            from .languages.kotlin import KotlinTreeSitterParser
+
+            self.language_specific_parser = KotlinTreeSitterParser(self)
+        elif self.language_name == "scala":
+            from .languages.scala import ScalaTreeSitterParser
+
+            self.language_specific_parser = ScalaTreeSitterParser(self)
+        elif self.language_name == "swift":
+            from .languages.swift import SwiftTreeSitterParser
+
+            self.language_specific_parser = SwiftTreeSitterParser(self)
+        elif self.language_name == "haskell":
+            from .languages.haskell import HaskellTreeSitterParser
+
+            self.language_specific_parser = HaskellTreeSitterParser(self)
+        elif self.language_name == "dart":
+            from .languages.dart import DartTreeSitterParser
+
+            self.language_specific_parser = DartTreeSitterParser(self)
+        elif self.language_name == "perl":
+            from .languages.perl import PerlTreeSitterParser
+
+            self.language_specific_parser = PerlTreeSitterParser(self)
+        elif self.language_name == "elixir":
+            from .languages.elixir import ElixirTreeSitterParser
+
+            self.language_specific_parser = ElixirTreeSitterParser(self)
+
+    def parse(self, path: Path, is_dependency: bool = False, **kwargs) -> Dict:
+        """Dispatches parsing to the language-specific parser."""
+        if self.language_specific_parser:
+            return self.language_specific_parser.parse(path, is_dependency, **kwargs)
+        raise NotImplementedError(f"No language-specific parser implemented for {self.language_name}")

codegraphcontext/utils/debug_log.py

@@ -0,0 +1,90 @@
+import os
+from datetime import datetime
+import logging
+from pathlib import Path
+logger = logging.getLogger(__name__)
+
+# Log level mapping
+LOG_LEVELS = {
+    'DEBUG': logging.DEBUG,
+    'INFO': logging.INFO,
+    'WARNING': logging.WARNING,
+    'ERROR': logging.ERROR,
+    'CRITICAL': logging.CRITICAL,
+    'DISABLED': logging.CRITICAL + 10  # Higher than CRITICAL to disable all
+}
+
+def _get_config_value(key, default):
+    """Helper to get config value with fallback"""
+    try:
+        from codegraphcontext.cli.config_manager import get_config_value
+        value = get_config_value(key)
+        if value is None:
+            return default
+        # Convert string boolean to actual boolean
+        if isinstance(value, str):
+            if value.lower() in ('true', 'false'):
+                return value.lower() == 'true'
+        return value
+    except Exception:
+        return default
+
+def _should_log(level_name):
+    """Check if a message at the given level should be logged"""
+    configured_level = _get_config_value('ENABLE_APP_LOGS', 'INFO')
+    
+    # Handle legacy boolean values
+    if isinstance(configured_level, bool):
+        return configured_level
+    
+    # Convert to uppercase for comparison
+    configured_level = str(configured_level).upper()
+    
+    # If disabled, don't log anything
+    if configured_level == 'DISABLED':
+        return False
+    
+    # Get numeric levels
+    configured_numeric = LOG_LEVELS.get(configured_level, logging.INFO)
+    message_numeric = LOG_LEVELS.get(level_name.upper(), logging.INFO)
+    
+    # Log if message level >= configured level
+    return message_numeric >= configured_numeric
+
+def debug_log(message):
+    """Write debug message to a file if DEBUG_LOGS is enabled"""
+    # Check if debug logging is enabled via config
+    debug_mode = _get_config_value('DEBUG_LOGS', False)
+    if not debug_mode:
+        return
+    
+    # Get debug log path from config
+    debug_file = _get_config_value('DEBUG_LOG_PATH', os.path.expanduser("~/mcp_debug.log"))
+    
+    # Ensure parent directory exists
+    Path(debug_file).parent.mkdir(parents=True, exist_ok=True)
+    
+    timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+    with open(debug_file, "a") as f:
+        f.write(f"[{timestamp}] {message}\n")
+        f.flush()
+
+def info_logger(msg):
+    """Log info message if log level allows"""
+    if _should_log('INFO'):
+        return logger.info(msg)
+
+def error_logger(msg):
+    """Log error message if log level allows"""
+    if _should_log('ERROR'):
+        return logger.error(msg)
+    
+def warning_logger(msg):
+    """Log warning message if log level allows"""
+    if _should_log('WARNING'):
+        return logger.warning(msg)
+    
+def debug_logger(msg):
+    """Log debug message if log level allows"""
+    if _should_log('DEBUG'):
+        return logger.debug(msg)

codegraphcontext/utils/path_ignore.py

@@ -0,0 +1,55 @@
+"""
+Path segment helpers aligned with IGNORE_DIRS indexing rules.
+
+`is_dependency` on graph nodes marks separately indexed packages, not vendored
+dirs inside a repo (e.g. node_modules). Analysis queries must also exclude
+those paths when IGNORE_DIRS would skip them during indexing.
+"""
+
+from pathlib import Path
+from typing import List, Optional
+
+from ..cli.config_manager import DEFAULT_CONFIG, get_config_value
+
+
+def parse_ignore_dir_names() -> List[str]:
+    """Directory names from IGNORE_DIRS, falling back to defaults when unset or empty."""
+    raw = (get_config_value("IGNORE_DIRS") or "").strip()
+    if not raw:
+        raw = DEFAULT_CONFIG["IGNORE_DIRS"]
+    return [d.strip() for d in raw.split(",") if d.strip()]
+
+
+def cypher_path_not_under_ignore_dirs(path_var: str, ignore_dir_names: Optional[List[str]] = None) -> str:
+    """
+    Returns a Cypher fragment that keeps only paths not under any IGNORE_DIRS segment
+    (Unix `/name/` or Windows `\\name\\`).
+    """
+    names = ignore_dir_names if ignore_dir_names is not None else parse_ignore_dir_names()
+    if not names:
+        return ""
+    parts: List[str] = []
+    for d in names:
+        esc = d.replace("\\", "\\\\").replace("'", "\\'")
+        parts.append(f"{path_var} CONTAINS '/{esc}/'")
+        parts.append(f"{path_var} CONTAINS '\\\\{esc}\\\\'")
+    return " AND NOT (" + " OR ".join(parts) + ")"
+
+
+def file_path_has_ignore_dir_segment(file_path: Path, index_root: Path) -> bool:
+    """
+    True if any directory segment of file_path relative to index_root matches
+    IGNORE_DIRS (same logic as Tree-sitter indexing).
+    """
+    ignore_dirs_str = (get_config_value("IGNORE_DIRS") or "").strip()
+    if not ignore_dirs_str:
+        ignore_dirs_str = DEFAULT_CONFIG["IGNORE_DIRS"]
+    ignore_dirs = {d.strip().lower() for d in ignore_dirs_str.split(",") if d.strip()}
+    if not ignore_dirs:
+        return False
+    try:
+        rel = file_path.resolve().relative_to(index_root.resolve())
+        parts = {p.lower() for p in rel.parent.parts}
+        return bool(parts.intersection(ignore_dirs))
+    except ValueError:
+        return False

codegraphcontext/utils/repo_path.py

@@ -0,0 +1,27 @@
+"""Helpers for comparing indexed repository records to filesystem paths.
+
+Rows with *no* path are skipped so the CLI never raises on ``Path(None)``. That is
+intentional: corrupted graph data should not block indexing. When the graph is
+queried, ``CodeFinder.list_indexed_repositories`` emits a ``logging`` warning if
+any ``Repository`` row has a missing path, so the issue is visible in normal CLI
+runs (see application logging configuration in ``cli.main``).
+"""
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any, Dict, Iterable
+
+
+def repo_record_matches_path(repo: Dict[str, Any], path_obj: Path) -> bool:
+    """True if *repo* has a resolvable path equal to *path_obj* (resolved)."""
+    raw = repo.get("path")
+    if raw is None or raw == "":
+        return False
+    try:
+        return Path(raw).resolve() == path_obj
+    except (TypeError, OSError, ValueError):
+        return False
+
+
+def any_repo_matches_path(repos: Iterable[Dict[str, Any]], path_obj: Path) -> bool:
+    return any(repo_record_matches_path(r, path_obj) for r in repos)