codegraphcontext 0.1.4__tar.gz → 0.1.5__tar.gz

{codegraphcontext-0.1.4/src/codegraphcontext.egg-info → codegraphcontext-0.1.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codegraphcontext
-Version: 0.1.4
+Version: 0.1.5
 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
@@ -123,6 +123,12 @@ Once the server is running, you can interact with it through your AI assistant u
     OR
     -   "Keep the code graph updated for the project I'm working on at `~/dev/main-app`."
 
+    When you ask to watch a directory, the system performs two actions at once:
+    1.  It kicks off a full scan to index all the code in that directory. This process runs in the background, and you'll receive a `job_id` to track its progress.
+    2.  It begins watching the directory for any file changes to keep the graph updated in real-time.
+
+    This means you can start by simply telling the system to watch a directory, and it will handle both the initial indexing and the continuous updates automatically.
+
 ### Querying and Understanding Code
 
 -   **Finding where code is defined:**

{codegraphcontext-0.1.4 → codegraphcontext-0.1.5}/README.md

@@ -72,6 +72,12 @@ Once the server is running, you can interact with it through your AI assistant u
     OR
     -   "Keep the code graph updated for the project I'm working on at `~/dev/main-app`."
 
+    When you ask to watch a directory, the system performs two actions at once:
+    1.  It kicks off a full scan to index all the code in that directory. This process runs in the background, and you'll receive a `job_id` to track its progress.
+    2.  It begins watching the directory for any file changes to keep the graph updated in real-time.
+
+    This means you can start by simply telling the system to watch a directory, and it will handle both the initial indexing and the continuous updates automatically.
+
 ### Querying and Understanding Code
 
 -   **Finding where code is defined:**

{codegraphcontext-0.1.4 → codegraphcontext-0.1.5}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "codegraphcontext"
-version = "0.1.4"
+version = "0.1.5"
 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.4 → codegraphcontext-0.1.5}/src/codegraphcontext/core/jobs.py

@@ -5,6 +5,8 @@ from datetime import datetime, timedelta
 from dataclasses import dataclass, asdict
 from enum import Enum
 from typing import Any, Dict, List, Optional
+from pathlib import Path
+
 
 class JobStatus(Enum):
     """Job status enumeration"""
@@ -90,6 +92,23 @@ class JobManager:
         with self.lock:
             return list(self.jobs.values())
 
+    def find_active_job_by_path(self, path: str) -> Optional[JobInfo]:
+        """Finds the most recent, active job for a given path."""
+        with self.lock:
+            path_obj = Path(path).resolve()
+            
+            matching_jobs = sorted(
+                [job for job in self.jobs.values() if job.path and Path(job.path).resolve() == path_obj],
+                key=lambda j: j.start_time,
+                reverse=True
+            )
+
+            for job in matching_jobs:
+                if job.status in [JobStatus.PENDING, JobStatus.RUNNING]:
+                    return job
+                    
+            return None
+
     def cleanup_old_jobs(self, max_age_hours: int = 24):
         """Clean up jobs older than specified hours"""
         cutoff_time = datetime.now() - timedelta(hours=max_age_hours)

{codegraphcontext-0.1.4 → codegraphcontext-0.1.5}/src/codegraphcontext/core/watcher.py

@@ -10,6 +10,7 @@ from watchdog.events import FileSystemEventHandler
 # The actual object is passed in __init__
 if typing.TYPE_CHECKING:
     from codegraphcontext.tools.graph_builder import GraphBuilder
+    from codegraphcontext.core.jobs import JobManager
 
 
 logger = logging.getLogger(__name__)
@@ -69,22 +70,40 @@ class DebouncedEventHandler(FileSystemEventHandler):
 
 class CodeWatcher:
     """Manages file system watching in a background thread."""
-    def __init__(self, graph_builder: "GraphBuilder"):
+    def __init__(self, graph_builder: "GraphBuilder", job_manager: "JobManager"):
         self.graph_builder = graph_builder
+        self.job_manager = job_manager
         self.observer = Observer()
         self.watched_paths = set()
         self.event_handler = DebouncedEventHandler(self.graph_builder)
 
     def watch_directory(self, path: str):
-        """Starts watching a directory if not already watched."""
-        path = str(Path(path).resolve())
-        if path in self.watched_paths:
-            logger.info(f"Path already being watched: {path}")
-            return
+        """
+        Starts watching a directory and returns the job ID for the initial scan if found.
+        """
+        path_obj = Path(path).resolve()
+        path_str = str(path_obj)
+
+        if path_str in self.watched_paths:
+            logger.info(f"Path already being watched: {path_str}")
+            return {"message": f"Path already being watched: {path_str}"}
         
-        self.observer.schedule(self.event_handler, path, recursive=True)
-        self.watched_paths.add(path)
-        logger.info(f"Started watching for code changes in: {path}")
+        self.observer.schedule(self.event_handler, path_str, recursive=True)
+        self.watched_paths.add(path_str)
+        logger.info(f"Started watching for code changes in: {path_str}")
+
+        active_job = self.job_manager.find_active_job_by_path(path_str)
+
+        response = {
+            "message": f"Started watching {path_str} for changes."
+        }
+        if active_job:
+            response["job_id"] = active_job.job_id
+            response["message"] += f" An initial scan is in progress under job ID: {active_job.job_id}"
+        else:
+            response["note"] = "No active initial scan was found for this path. The watcher will only process new changes."
+        
+        return response
 
     def start(self):
         """Starts the observer thread."""

{codegraphcontext-0.1.4 → codegraphcontext-0.1.5}/src/codegraphcontext/server.py

@@ -60,7 +60,7 @@ class MCPServer:
         self.code_finder = CodeFinder(self.db_manager)
         self.import_extractor = ImportExtractor()
         
-        self.code_watcher = CodeWatcher(self.graph_builder)
+        self.code_watcher = CodeWatcher(self.graph_builder, self.job_manager)
         
         self._init_tools()
 
@@ -69,7 +69,7 @@ class MCPServer:
         self.tools = {
             "add_code_to_graph": {
                 "name": "add_code_to_graph",
-                "description": "Add code from a local folder to the graph. Returns a job ID for background processing.",
+                "description": "Performs a one-time scan of a local folder to add its code to the graph. Ideal for indexing libraries, dependencies, or projects not being actively modified. Returns a job ID for background processing.",
                 "inputSchema": {
                     "type": "object",
                     "properties": {
@@ -117,7 +117,7 @@ class MCPServer:
             },
             "watch_directory": {
                 "name": "watch_directory",
-                "description": "Start watching a directory for code changes and automatically update the graph.",
+                "description": "Performs an initial scan of a directory and then continuously monitors it for changes, automatically keeping the graph up-to-date. Ideal for projects under active development. Returns a job ID for the initial scan.",
                 "inputSchema": {
                     "type": "object",
                     "properties": { "path": {"type": "string", "description": "Path to directory to watch"} },
@@ -166,6 +166,47 @@ class MCPServer:
                     "properties": {},
                     "additionalProperties": False
                 }
+            },
+            "calculate_cyclomatic_complexity": {
+                "name": "calculate_cyclomatic_complexity",
+                "description": "Calculate the cyclomatic complexity of a specific function to measure its complexity.",
+                "inputSchema": {
+                    "type": "object",
+                    "properties": {
+                        "function_name": {"type": "string", "description": "The name of the function to analyze."},
+                        "file_path": {"type": "string", "description": "Optional: The full path to the file containing the function for a more specific query."}
+                    },
+                    "required": ["function_name"]
+                }
+            },
+            "find_most_complex_functions": {
+                "name": "find_most_complex_functions",
+                "description": "Find the most complex functions in the codebase based on cyclomatic complexity.",
+                "inputSchema": {
+                    "type": "object",
+                    "properties": {
+                        "limit": {"type": "integer", "description": "The maximum number of complex functions to return.", "default": 10}
+                    }
+                }
+            },
+            "list_indexed_repositories": {
+                "name": "list_indexed_repositories",
+                "description": "List all indexed repositories.",
+                "inputSchema": {
+                    "type": "object",
+                    "properties": {}
+                }
+            },
+            "delete_repository": {
+                "name": "delete_repository",
+                "description": "Delete an indexed repository from the graph.",
+                "inputSchema": {
+                    "type": "object",
+                    "properties": {
+                        "repo_path": {"type": "string", "description": "The path of the repository to delete."}
+                    },
+                    "required": ["repo_path"]
+                }
             }
             # Other tools like list_imports, add_package_to_graph can be added here following the same pattern
         }
@@ -276,6 +317,70 @@ class MCPServer:
             debug_log(f"Error finding dead code: {str(e)}")
             return {"error": f"Failed to find dead code: {str(e)}"}
 
+    def calculate_cyclomatic_complexity_tool(self, **args) -> Dict[str, Any]:
+        """Tool to calculate cyclomatic complexity for a given function."""
+        function_name = args.get("function_name")
+        file_path = args.get("file_path")
+
+        try:
+            debug_log(f"Calculating cyclomatic complexity for function: {function_name}")
+            results = self.code_finder.get_cyclomatic_complexity(function_name, file_path)
+            
+            response = {
+                "success": True,
+                "function_name": function_name,
+                "results": results
+            }
+            if file_path:
+                response["file_path"] = file_path
+            
+            return response
+        except Exception as e:
+            debug_log(f"Error calculating cyclomatic complexity: {str(e)}")
+            return {"error": f"Failed to calculate cyclomatic complexity: {str(e)}"}
+
+    def find_most_complex_functions_tool(self, **args) -> Dict[str, Any]:
+        """Tool to find the most complex functions."""
+        limit = args.get("limit", 10)
+        try:
+            debug_log(f"Finding the top {limit} most complex functions.")
+            results = self.code_finder.find_most_complex_functions(limit)
+            return {
+                "success": True,
+                "limit": limit,
+                "results": results
+            }
+        except Exception as e:
+            debug_log(f"Error finding most complex functions: {str(e)}")
+            return {"error": f"Failed to find most complex functions: {str(e)}"}
+
+    def list_indexed_repositories_tool(self, **args) -> Dict[str, Any]:
+        """Tool to list indexed repositories."""
+        try:
+            debug_log("Listing indexed repositories.")
+            results = self.code_finder.list_indexed_repositories()
+            return {
+                "success": True,
+                "repositories": results
+            }
+        except Exception as e:
+            debug_log(f"Error listing indexed repositories: {str(e)}")
+            return {"error": f"Failed to list indexed repositories: {str(e)}"}
+
+    def delete_repository_tool(self, **args) -> Dict[str, Any]:
+        """Tool to delete a repository from the graph."""
+        repo_path = args.get("repo_path")
+        try:
+            debug_log(f"Deleting repository: {repo_path}")
+            self.graph_builder.delete_repository_from_graph(repo_path)
+            return {
+                "success": True,
+                "message": f"Repository '{repo_path}' deleted successfully."
+            }
+        except Exception as e:
+            debug_log(f"Error deleting repository: {str(e)}")
+            return {"error": f"Failed to delete repository: {str(e)}"}
+
     def watch_directory_tool(self, **args) -> Dict[str, Any]:
         """Tool to start watching a directory."""
         path = args.get("path")
@@ -283,17 +388,23 @@ class MCPServer:
             return {"error": f"Invalid path provided: {path}. Must be a directory."}
 
         try:
-            initial_scan_result = self.add_code_to_graph_tool(path=path, is_dependency=False)
-            if "error" in initial_scan_result:
-                return initial_scan_result
+            # First, ensure the code is added/scanned
+            scan_job_result = self.add_code_to_graph_tool(path=path, is_dependency=False)
+            if "error" in scan_job_result:
+                return scan_job_result
 
-            self.code_watcher.watch_directory(path)
+            # Now, start the watcher
+            watch_result = self.code_watcher.watch_directory(path)
             
-            return {
+            # Combine results
+            final_result = {
                 "success": True,
-                "message": f"Initial scan started (Job ID: {initial_scan_result.get('job_id')}). Now watching for live changes in {path}.",
-                "instructions": "Changes to .py files in this directory will now be automatically updated in the graph."
+                "message": f"Initial scan started for {path}. Now watching for live changes.",
+                "job_id": scan_job_result.get("job_id"),
+                "details": watch_result
             }
+            return final_result
+            
         except Exception as e:
             logger.error(f"Failed to start watching directory {path}: {e}")
             return {"error": f"Failed to start watching directory: {str(e)}"}
@@ -555,7 +666,11 @@ class MCPServer:
             "execute_cypher_query": self.execute_cypher_query_tool,
             "add_code_to_graph": self.add_code_to_graph_tool,
             "check_job_status": self.check_job_status_tool,
-            "list_jobs": self.list_jobs_tool
+            "list_jobs": self.list_jobs_tool,
+            "calculate_cyclomatic_complexity": self.calculate_cyclomatic_complexity_tool,
+            "find_most_complex_functions": self.find_most_complex_functions_tool,
+            "list_indexed_repositories": self.list_indexed_repositories_tool,
+            "delete_repository": self.delete_repository_tool
         }
         handler = tool_map.get(tool_name)
         if handler:

{codegraphcontext-0.1.4 → codegraphcontext-0.1.5}/src/codegraphcontext/tools/code_finder.py

@@ -522,6 +522,14 @@ class CodeFinder:
                     "summary": f"Found {len(results['potentially_unused_functions'])} potentially unused functions"
                 }
             
+            elif query_type == "find_complexity":
+                limit = int(context) if context and context.isdigit() else 10
+                results = self.find_most_complex_functions(limit)
+                return {
+                    "query_type": "find_complexity", "limit": limit, "results": results,
+                    "summary": f"Found the top {len(results)} most complex functions"
+                }
+            
             elif query_type in ["call_chain", "path", "chain"]:
                 if '->' in target:
                     start_func, end_func = target.split('->', 1)
@@ -556,7 +564,7 @@ class CodeFinder:
                     "supported_types": [
                         "find_callers", "find_callees", "find_importers", "who_modifies",
                         "class_hierarchy", "overrides", "dead_code", "call_chain",
-                        "module_deps", "variable_scope"
+                        "module_deps", "variable_scope", "find_complexity"
                     ]
                 }
         
@@ -566,3 +574,46 @@ class CodeFinder:
                 "query_type": query_type,
                 "target": target
             }
+
+    def get_cyclomatic_complexity(self, function_name: str, file_path: str = None) -> List[Dict]:
+        """Get the cyclomatic complexity of a function."""
+        with self.driver.session() as session:
+            if file_path:
+                # Use ENDS WITH for flexible path matching
+                query = """
+                    MATCH (f:Function {name: $function_name})
+                    WHERE f.file_path ENDS WITH $file_path
+                    RETURN f.name as function_name, f.file_path as file_path, f.cyclomatic_complexity as complexity
+                """
+                result = session.run(query, function_name=function_name, file_path=file_path)
+            else:
+                query = """
+                    MATCH (f:Function {name: $function_name})
+                    RETURN f.name as function_name, f.file_path as file_path, f.cyclomatic_complexity as complexity
+                """
+                result = session.run(query, function_name=function_name)
+            
+            return [dict(record) for record in result]
+
+    def find_most_complex_functions(self, limit: int = 10) -> List[Dict]:
+        """Find the most complex functions based on cyclomatic complexity."""
+        with self.driver.session() as session:
+            query = """
+                MATCH (f:Function)
+                WHERE f.cyclomatic_complexity IS NOT NULL
+                RETURN f.name as function_name, f.file_path as file_path, f.cyclomatic_complexity as complexity, f.line_number as line_number
+                ORDER BY f.cyclomatic_complexity DESC
+                LIMIT $limit
+            """
+            result = session.run(query, limit=limit)
+            return [dict(record) for record in result]
+
+    def list_indexed_repositories(self) -> List[Dict]:
+        """List all indexed repositories."""
+        with self.driver.session() as session:
+            result = session.run("""
+                MATCH (r:Repository)
+                RETURN r.name as name, r.path as path, r.is_dependency as is_dependency
+                ORDER BY r.name
+            """)
+            return [dict(record) for record in result]

{codegraphcontext-0.1.4 → codegraphcontext-0.1.5}/src/codegraphcontext/tools/graph_builder.py

@@ -23,6 +23,68 @@ def debug_log(message):
         f.flush()
 
 
+class CyclomaticComplexityVisitor(ast.NodeVisitor):
+    """Calculates cyclomatic complexity for a given AST node."""
+    def __init__(self):
+        self.complexity = 1
+
+    def visit_If(self, node):
+        self.complexity += 1
+        self.generic_visit(node)
+
+    def visit_For(self, node):
+        self.complexity += 1
+        self.generic_visit(node)
+
+    def visit_While(self, node):
+        self.complexity += 1
+        self.generic_visit(node)
+
+    def visit_With(self, node):
+        self.complexity += len(node.items)
+        self.generic_visit(node)
+
+    def visit_AsyncFor(self, node):
+        self.complexity += 1
+        self.generic_visit(node)
+
+    def visit_AsyncWith(self, node):
+        self.complexity += len(node.items)
+        self.generic_visit(node)
+
+    def visit_ExceptHandler(self, node):
+        self.complexity += 1
+        self.generic_visit(node)
+
+    def visit_BoolOp(self, node):
+        self.complexity += len(node.values) - 1
+        self.generic_visit(node)
+
+    def visit_ListComp(self, node):
+        self.complexity += len(node.generators)
+        self.generic_visit(node)
+
+    def visit_SetComp(self, node):
+        self.complexity += len(node.generators)
+        self.generic_visit(node)
+
+    def visit_DictComp(self, node):
+        self.complexity += len(node.generators)
+        self.generic_visit(node)
+
+    def visit_GeneratorExp(self, node):
+        self.complexity += len(node.generators)
+        self.generic_visit(node)
+
+    def visit_IfExp(self, node):
+        self.complexity += 1
+        self.generic_visit(node)
+
+    def visit_match_case(self, node):
+        self.complexity += 1
+        self.generic_visit(node)
+
+
 class CodeVisitor(ast.NodeVisitor):
     """Enhanced AST visitor to extract code elements with better function call detection"""
 
@@ -62,6 +124,9 @@ class CodeVisitor(ast.NodeVisitor):
 
     def visit_FunctionDef(self, node):
         """Visit function definitions"""
+        complexity_visitor = CyclomaticComplexityVisitor()
+        complexity_visitor.visit(node)
+        
         func_data = {
             "name": node.name,
             "line_number": node.lineno,
@@ -76,6 +141,7 @@ class CodeVisitor(ast.NodeVisitor):
                 ast.unparse(dec) if hasattr(ast, "unparse") else ""
                 for dec in node.decorator_list
             ],
+            "cyclomatic_complexity": complexity_visitor.complexity,
         }
         self.functions.append(func_data)
         self._push_context(node.name, "function", node.lineno)
@@ -236,6 +302,7 @@ class GraphBuilder:
             try:
                 session.run("CREATE CONSTRAINT repository_path IF NOT EXISTS FOR (r:Repository) REQUIRE r.path IS UNIQUE")
                 session.run("CREATE CONSTRAINT file_path IF NOT EXISTS FOR (f:File) REQUIRE f.path IS UNIQUE")
+                session.run("CREATE CONSTRAINT directory_path IF NOT EXISTS FOR (d:Directory) REQUIRE d.path IS UNIQUE")
                 session.run("CREATE CONSTRAINT function_unique IF NOT EXISTS FOR (f:Function) REQUIRE (f.name, f.file_path, f.line_number) IS UNIQUE")
                 session.run("CREATE CONSTRAINT class_unique IF NOT EXISTS FOR (c:Class) REQUIRE (c.name, c.file_path, c.line_number) IS UNIQUE")
                 session.run("CREATE CONSTRAINT variable_unique IF NOT EXISTS FOR (v:Variable) REQUIRE (v.name, v.file_path, v.line_number) IS UNIQUE")
@@ -280,12 +347,42 @@ class GraphBuilder:
             except ValueError:
                 relative_path = file_name
 
+            # Create/Merge the file node
             session.run("""
-                MATCH (r:Repository {name: $repo_name})
                 MERGE (f:File {path: $path})
                 SET f.name = $name, f.relative_path = $relative_path, f.is_dependency = $is_dependency
-                MERGE (r)-[:CONTAINS]->(f)
-            """, repo_name=repo_name, path=file_path_str, name=file_name, relative_path=relative_path, is_dependency=is_dependency)
+            """, path=file_path_str, name=file_name, relative_path=relative_path, is_dependency=is_dependency)
+
+            # Create directory structure and link it
+            file_path_obj = Path(file_path_str)
+            repo_path_obj = Path(repo_result['path'])
+            
+            relative_path_to_file = file_path_obj.relative_to(repo_path_obj)
+            
+            parent_path = str(repo_path_obj)
+            parent_label = 'Repository'
+
+            # Create nodes for each directory part of the path
+            for part in relative_path_to_file.parts[:-1]: # For each directory in the path
+                current_path = Path(parent_path) / part
+                current_path_str = str(current_path)
+                
+                session.run(f"""
+                    MATCH (p:{parent_label} {{path: $parent_path}})
+                    MERGE (d:Directory {{path: $current_path}})
+                    SET d.name = $part
+                    MERGE (p)-[:CONTAINS]->(d)
+                """, parent_path=parent_path, current_path=current_path_str, part=part)
+
+                parent_path = current_path_str
+                parent_label = 'Directory'
+
+            # Link the last directory/repository to the file
+            session.run(f"""
+                MATCH (p:{parent_label} {{path: $parent_path}})
+                MATCH (f:File {{path: $file_path}})
+                MERGE (p)-[:CONTAINS]->(f)
+            """, parent_path=parent_path, file_path=file_path_str)
 
             for item_data, label in [(file_data['functions'], 'Function'), (file_data['classes'], 'Class'), (file_data['variables'], 'Variable')]:
                 for item in item_data:
@@ -444,6 +541,14 @@ class GraphBuilder:
         """Deletes a file and all its contained elements and relationships."""
         file_path_str = str(Path(file_path).resolve())
         with self.driver.session() as session:
+            # Get parent directories
+            parents_res = session.run("""
+                MATCH (f:File {path: $path})<-[:CONTAINS*]-(d:Directory)
+                RETURN d.path as path ORDER BY length(d.path) DESC
+            """, path=file_path_str)
+            parent_paths = [record["path"] for record in parents_res]
+
+            # Delete the file and its contents
             session.run(
                 """
                 MATCH (f:File {path: $path})
@@ -454,6 +559,25 @@ class GraphBuilder:
             )
             logger.info(f"Deleted file and its elements from graph: {file_path_str}")
 
+            # Clean up empty parent directories, starting from the deepest
+            for path in parent_paths:
+                session.run("""
+                    MATCH (d:Directory {path: $path})
+                    WHERE NOT (d)-[:CONTAINS]->()
+                    DETACH DELETE d
+                """, path=path)
+
+    def delete_repository_from_graph(self, repo_path: str):
+        """Deletes a repository and all its contents from the graph."""
+        repo_path_str = str(Path(repo_path).resolve())
+        with self.driver.session() as session:
+            session.run("""
+                MATCH (r:Repository {path: $path})
+                OPTIONAL MATCH (r)-[:CONTAINS*]->(e)
+                DETACH DELETE r, e
+            """, path=repo_path_str)
+            logger.info(f"Deleted repository and its contents from graph: {repo_path_str}")
+
     def update_file_in_graph(self, file_path: Path):
         """Updates a file by deleting and re-adding it."""
         file_path_str = str(file_path.resolve())

{codegraphcontext-0.1.4 → codegraphcontext-0.1.5/src/codegraphcontext.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codegraphcontext
-Version: 0.1.4
+Version: 0.1.5
 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
@@ -123,6 +123,12 @@ Once the server is running, you can interact with it through your AI assistant u
     OR
     -   "Keep the code graph updated for the project I'm working on at `~/dev/main-app`."
 
+    When you ask to watch a directory, the system performs two actions at once:
+    1.  It kicks off a full scan to index all the code in that directory. This process runs in the background, and you'll receive a `job_id` to track its progress.
+    2.  It begins watching the directory for any file changes to keep the graph updated in real-time.
+
+    This means you can start by simply telling the system to watch a directory, and it will handle both the initial indexing and the continuous updates automatically.
+
 ### Querying and Understanding Code
 
 -   **Finding where code is defined:**