Staging

.github/workflows/python-app.yml

@@ -5,9 +5,9 @@
 
 on:
   push:
-    branches: [ "main" ]
+    branches: [ "main", "staging" ]
   pull_request:
-    branches: [ "main" ]
+    branches: [ "main", "staging" ]
 
 permissions:
   contents: read
@@ -19,15 +19,16 @@
 
     steps:
     - uses: actions/checkout@v4
-    - name: Set up Python 3.10
-      uses: actions/setup-python@v3
+    - name: Install uv
+      uses: astral-sh/setup-uv@v4
+    - name: Set up Python 3.12
+      uses: actions/setup-python@v5
       with:
-        python-version: "3.10"
+        python-version: "3.12"
     - name: Install dependencies
       run: |
-        python -m pip install --upgrade pip
-        pip install flake8 pytest
-        if [ -f requirements.txt ]; then pip install -r requirements.txt; fi
+        uv pip install --system flake8 pytest
+        uv pip install --system .
     - name: Lint with flake8
       run: |
         # stop the build if there are Python syntax errors or undefined names

README.md

@@ -22,9 +22,17 @@ docker run -p 6379:6379 -p 3000:3000 -it --rm falkordb/falkordb:latest
 
 Create your own `.env` file from the `.env.template` file
 
+### Install dependencies
+
+Install project dependencies:
+
+```bash
+uv sync
+```
+
 Start the server:
 ```bash
-flask --app api/index.py run --debug
+uv run flask --app api/index.py run --debug
 ```
 
 ### Creating a graph

api/analyzers/source_analyzer.py

@@ -143,20 +143,23 @@ def second_pass(self, graph: Graph, files: list[Path], path: Path) -> None:
                 logging.info(f'Processing file ({i + 1}/{files_len}): {file_path}')
                 for _, entity in file.entities.items():
                     entity.resolved_symbol(lambda key, symbol: analyzers[file_path.suffix].resolve_symbol(self.files, lsps[file_path.suffix], file_path, path, key, symbol))
-                    for key, symbols in entity.resolved_symbols.items():
+                    for key, symbols in entity.symbols.items():
                         for symbol in symbols:
+                            if len(symbol.resolved_symbol) == 0:
+                                continue
+                            resolved_symbol = next(iter(symbol.resolved_symbol))
                             if key == "base_class":
-                                graph.connect_entities("EXTENDS", entity.id, symbol.id)
+                                graph.connect_entities("EXTENDS", entity.id, resolved_symbol.id)
                             elif key == "implement_interface":
-                                graph.connect_entities("IMPLEMENTS", entity.id, symbol.id)
+                                graph.connect_entities("IMPLEMENTS", entity.id, resolved_symbol.id)
                             elif key == "extend_interface":
-                                graph.connect_entities("EXTENDS", entity.id, symbol.id)
+                                graph.connect_entities("EXTENDS", entity.id, resolved_symbol.id)
                             elif key == "call":
-                                graph.connect_entities("CALLS", entity.id, symbol.id)
+                                graph.connect_entities("CALLS", entity.id, resolved_symbol.id, {"line": symbol.symbol.start_point.row, "text": symbol.symbol.text.decode("utf-8")})
                             elif key == "return_type":
-                                graph.connect_entities("RETURNS", entity.id, symbol.id)
+                                graph.connect_entities("RETURNS", entity.id, resolved_symbol.id)
                             elif key == "parameters":
-                                graph.connect_entities("PARAMETERS", entity.id, symbol.id)
+                                graph.connect_entities("PARAMETERS", entity.id, resolved_symbol.id)
 
     def analyze_files(self, files: list[Path], path: Path, graph: Graph) -> None:
         self.first_pass(path, files, [], graph)

api/entities/entity.py

@@ -1,31 +1,31 @@
 from typing import Callable, Self
 from tree_sitter import Node
 
+class Symbol:
+    def __init__(self, symbol: Node):
+        self.symbol = symbol
+        self.resolved_symbol = set()
+
+    def add_resolve_symbol(self, resolved_symbol):
+        self.resolved_symbol.add(resolved_symbol)
 
 class Entity:
     def __init__(self, node: Node):
         self.node = node
-        self.symbols: dict[str, list[Node]] = {}
-        self.resolved_symbols: dict[str, set[Self]] = {}
+        self.symbols: dict[str, list[Symbol]] = {}
         self.children: dict[Node, Self] = {}
 
     def add_symbol(self, key: str, symbol: Node):
         if key not in self.symbols:
             self.symbols[key] = []
-        self.symbols[key].append(symbol)
-
-    def add_resolved_symbol(self, key: str, symbol: Self):
-        if key not in self.resolved_symbols:
-            self.resolved_symbols[key] = set()
-        self.resolved_symbols[key].add(symbol)
+        self.symbols[key].append(Symbol(symbol))
 
     def add_child(self, child: Self):
         child.parent = self
         self.children[child.node] = child
 
     def resolved_symbol(self, f: Callable[[str, Node], list[Self]]):
         for key, symbols in self.symbols.items():
-            self.resolved_symbols[key] = set()
             for symbol in symbols:
-                for resolved_symbol in f(key, symbol):
-                    self.resolved_symbols[key].add(resolved_symbol)
+                for resolved_symbol in f(key, symbol.symbol):
+                    symbol.add_resolve_symbol(resolved_symbol)

api/graph.py

@@ -479,7 +479,7 @@ def set_file_coverage(self, path: str, name: str, ext: str, coverage: float) ->
 
         res = self._query(q, params)
 
-    def connect_entities(self, relation: str, src_id: int, dest_id: int) -> None:
+    def connect_entities(self, relation: str, src_id: int, dest_id: int, properties: dict = {}) -> None:
         """
         Establish a relationship between src and dest
 
@@ -491,9 +491,10 @@ def connect_entities(self, relation: str, src_id: int, dest_id: int) -> None:
         q = f"""MATCH (src), (dest)
                 WHERE ID(src) = $src_id AND ID(dest) = $dest_id
                 MERGE (src)-[e:{relation}]->(dest)
+                SET e += $properties
                 RETURN e"""
 
-        params = {'src_id': src_id, 'dest_id': dest_id}
+        params = {'src_id': src_id, 'dest_id': dest_id, "properties": properties}
         self._query(q, params)
 
     def function_calls_function(self, caller_id: int, callee_id: int, pos: int) -> None:

api/llm.py

@@ -235,8 +235,6 @@ def _define_ontology() -> Ontology:
 ontology = _define_ontology()
 
 def _create_kg_agent(repo_name: str):
-    global ontology
-
     model_name = os.getenv('MODEL_NAME', 'gemini/gemini-2.0-flash')
 
     model = LiteModel(model_name)