auto-complete

Author: swilly22

code_graph/__init__.py

@@ -1,5 +1,6 @@
-from .analyzers.source_analyzer import *
+from .graph import *
 from .entities import *
 from .git_utils import *
-from .graph import Graph
 from .code_coverage import *
+from .analyzers.source_analyzer import *
+from. auto_complete import auto_complete

code_graph/auto_complete.py

@@ -0,0 +1,8 @@
+from typing import List
+from .graph import Graph
+from .entities import Function
+
+def auto_complete(repo: str, prefix: str) -> str:
+    g = Graph(repo)
+    return g.prefix_search(prefix)
+

code_graph/graph.py

@@ -3,6 +3,24 @@
 from typing import List, Optional
 from falkordb import FalkorDB, Node, QueryResult
 
+FALKORDB_HOST     = "localhost"
+FALKORDB_PORT     = 6379
+FALKORDB_USERNAME = None
+FALKORDB_PASSWORD = None
+
+def list_repos() -> List[str]:
+    """
+        List processed repositories
+    """
+
+    db = FalkorDB(host=FALKORDB_HOST, port=FALKORDB_PORT,
+                  username=FALKORDB_USERNAME, password=FALKORDB_PASSWORD)
+
+    graphs = db.list_graphs()
+    print(f"graphs: {graphs}")
+    graphs = [g for g in graphs if not g.endswith('_git')]
+    return graphs
+
 class Graph():
     """
     Represents a connection to a graph database using FalkorDB.
@@ -34,6 +52,12 @@ def __init__(self, name: str, host: str = 'localhost', port: int = 6379,
         except Exception:
             pass
 
+        # index Function using full-text search
+        try:
+            self.g.create_node_fulltext_index("Searchable", "name")
+        except Exception:
+            pass
+
     def clone(self, clone: str) -> "Graph":
         """
         Create a copy of the graph under the name clone
@@ -71,7 +95,7 @@ def add_class(self, c: Class) -> None:
             c (Class): The Class object to be added.
         """
 
-        q = """MERGE (c:Class {name: $name, path: $path, src_start: $src_start,
+        q = """MERGE (c:Class:Searchable {name: $name, path: $path, src_start: $src_start,
                                src_end: $src_end})
                SET c.doc = $doc
                RETURN ID(c)"""
@@ -133,7 +157,7 @@ def add_function(self, func: Function) -> None:
             func (Function): The Function object to be added.
         """
 
-        q = """MERGE (f:Function {path: $path, name: $name,
+        q = """MERGE (f:Function:Searchable {path: $path, name: $name,
                                   src_start: $src_start, src_end: $src_end})
                SET f.args = $args, f.ret_type = $ret_type, f.src = $src, f.doc = $doc
                RETURN ID(f)"""
@@ -151,7 +175,6 @@ def add_function(self, func: Function) -> None:
             'ret_type': func.ret_type
         }
 
-
         res = self.g.query(q, params)
         func.id = res.result_set[0][0]
 
@@ -215,6 +238,53 @@ def get_function_by_name(self, name: str) -> Optional[Function]:
 
         return self._function_from_node(res[0][0])
 
+    def prefix_search(self, prefix: str) -> str:
+        """
+        Search for entities by prefix using a full-text search on the graph.
+        The search is limited to 10 nodes. Each node's name and labels are retrieved,
+        and the results are sorted based on their labels.
+
+        Args:
+            prefix (str): The prefix string to search for in the graph database.
+
+        Returns:
+            str: A list of entity names and corresponding labels, sorted by label.
+                 If no results are found or an error occurs, an empty list is returned.
+        """
+
+        # Append a wildcard '*' to the prefix for full-text search.
+        search_prefix = f"{prefix}*"
+
+        # Cypher query to perform full-text search and limit the result to 10 nodes.
+        # The 'CALL db.idx.fulltext.queryNodes' method searches for nodes labeled 'Searchable'
+        # that match the given prefix, collects the nodes, and returns the result.
+        query = """
+            CALL db.idx.fulltext.queryNodes('Searchable', $prefix)
+            YIELD node
+            WITH node
+            LIMIT 10
+            RETURN collect(node)
+        """
+
+        try:
+            # Execute the query using the provided graph database connection.
+            completions = self.g.query(query, {'prefix': search_prefix}).result_set[0][0]
+
+            # Remove label Searchable from each node
+            for node in completions:
+                node.labels.remove('Searchable')
+
+            # Sort the results by the label for better organization.
+            completions = sorted(completions, key=lambda x: x.labels)
+
+            return completions
+
+        except Exception as e:
+            # Log any errors encountered during the search and return an empty list.
+            logging.error(f"Error while searching for entities with prefix '{prefix}': {e}")
+            return []
+
+
     def get_function(self, func_id: int) -> Optional[Function]:
         q = """MATCH (f:Function)
                WHERE ID(f) = $func_id
@@ -269,7 +339,7 @@ def add_file(self, file: File) -> None:
             file_ext (str): Extension of the file.
         """
 
-        q = """MERGE (f:File {path: $path, name: $name, ext: $ext})
+        q = """MERGE (f:File:Searchable {path: $path, name: $name, ext: $ext})
                RETURN ID(f)"""
         params = {'path': file.path, 'name': file.name, 'ext': file.ext}
 
@@ -400,7 +470,7 @@ def add_struct(self, s: Struct) -> None:
             s (Struct): The Struct object to be added.
         """
 
-        q = """MERGE (s:Struct {name: $name, path: $path, src_start: $src_start,
+        q = """MERGE (s:Struct:Searchable {name: $name, path: $path, src_start: $src_start,
                                src_end: $src_end})
                SET s.doc = $doc, s.fields = $fields
                RETURN ID(s)"""
@@ -484,3 +554,4 @@ def rerun_query(self, q: str, params: dict) -> QueryResult:
         """
 
         return self.g.query(q, params)
+

main.py

@@ -32,41 +32,6 @@ def extract_org_name_from_url(url: str) -> Optional[tuple[str, str]]:
 
     return (components[n-2], components[n-1])
 
-def get_current_head_commit_hash(repo_url: str) -> str:
-    import git
-
-    with tempfile.TemporaryDirectory() as temp_dir:
-        repo = git.Repo.clone_from(repo_url, temp_dir)
-        commit_hash = repo.head.commit.hexsha
-    return commit_hash
-
-def save_repository_metadata(repo_url: str, repo_name: str):
-    r = redis.Redis(host=FALKORDB_HOST, port=FALKORDB_PORT,
-                    username=FALKORDB_USERNAME, password=FALKORDB_PASSWORD,
-                    decode_responses=True)
-
-    key = f'{repo_name}_metadata'
-    metadata = {
-            'repo_url': repo_url,
-            'repo_name': repo_name,
-            'date_create': str(datetime.datetime.today().replace(microsecond=0)),
-            'commit': get_current_head_commit_hash(repo_url)}
-
-    r.hset(key, mapping=metadata)
-
-@app.route('/list_repos', methods=['GET'])
-def list_repos():
-    r = redis.Redis(host=FALKORDB_HOST, port=FALKORDB_PORT,
-                    username=FALKORDB_USERNAME, password=FALKORDB_PASSWORD,
-                    decode_responses=True)
-    keys = r.keys('*_metadata')[:20]
-
-    repos = []
-    for key in keys:
-        repos.append(r.hgetall(key))
-
-    return jsonify({'repos': repos}), 200
-
 @app.route('/graph_entities', methods=['GET'])
 def graph_entities():
     # Access the 'graph_id' parameter from the GET request
@@ -297,6 +262,47 @@ def process_switch_commit():
 
     return jsonify(response), 200
 
+@app.route('/auto_complete', methods=['POST'])
+def process_auto_complete():
+    # Get JSON data from the request
+    data = request.get_json()
+
+    # path to local repository
+    repo = data.get('repo')
+    if repo is None:
+        return jsonify({'status': f'Missing mandatory parameter "repo"'}), 400
+
+    prefix = data.get('prefix')
+    if prefix is None:
+        return jsonify({'status': f'Missing mandatory parameter "prefix"'}), 400
+
+    completions = auto_complete(repo, prefix)
+    # Create a response
+    response = {
+        'status': 'success',
+        'completions': completions
+    }
+
+    return jsonify(response), 200
+
+
+@app.route('/list_repos', methods=['GET'])
+def process_list_repos():
+    print("Hello!")
+    # Get JSON data from the request
+
+    repos = list_repos()
+    print(f"repos: {repos}")
+
+    # Create a response
+    response = {
+        'status': 'success',
+        'repositories': repos
+    }
+
+    return jsonify(response), 200
+
+
 if __name__ == '__main__':
     app.run(debug=True)