codegraph-engine 2.2.1__py3-none-any.whl → 3.0.0__py3-none-any.whl

codegraph/indexing/parser.py

@@ -27,6 +27,9 @@ from codegraph.frameworks import (
     analyze_js_ts_mounts,
     get_python_analyzers,
 )
+from codegraph.frameworks_nestjs import analyze_nestjs_file
+from codegraph.frameworks_nextjs import analyze_nextjs_file
+from codegraph.frameworks_react import analyze_react_file
 from codegraph.semantic_decorators import analyze_symbol_decorators
 
 from .models import (
@@ -215,6 +218,9 @@ def parse(content: str, language: str, file_path: str) -> ParseResult:
     """Parse a source file in a single scoped pass."""
     if language == "python":
         return _parse_python(content, file_path)
+    if language == "html" or file_path.lower().endswith((".html", ".htm", ".jinja", ".jinja2", ".njk", ".ejs")):
+        from codegraph.indexing.templates import parse_html_template
+        return parse_html_template(content, file_path)
     if language in ("sql", "prisma"):
         source_hash = hashlib.sha256(content.encode("utf-8", errors="replace")).hexdigest()
         return ParseResult(
@@ -1360,6 +1366,48 @@ class _PythonScopeVisitor(ast.NodeVisitor):
                 self._extract_binding_from_assign(
                     target.id, node.value, node.lineno, getattr(node, "col_offset", None)
                 )
+                if target.id in ("template_name", "template") and isinstance(node.value, ast.Constant) and isinstance(node.value.value, str):
+                    self.bindings.append(
+                        BindingRef(
+                            target_name=node.value.value,
+                            file_path=self.file_path,
+                            line=node.lineno,
+                            column=getattr(node, "col_offset", None),
+                            scope=self.current_scope_qname or "",
+                            expr_kind="RENDERS_TEMPLATE",
+                            base_expr=self.current_scope_canonical_id or "",
+                            source_expr=node.value.value,
+                        )
+                    )
+                elif isinstance(node.value, ast.BinOp) and isinstance(node.value.op, ast.BitOr):
+                    # Unfold bitwise OR chain (e.g. prompt | llm | output_parser)
+                    pipe_steps: list[str] = []
+                    curr: ast.expr = node.value
+                    is_valid_pipe = True
+                    while isinstance(curr, ast.BinOp) and isinstance(curr.op, ast.BitOr):
+                        r_text = ast.unparse(curr.right).strip() if hasattr(ast, "unparse") else ""
+                        if not r_text or isinstance(curr.right, ast.Constant):
+                            is_valid_pipe = False
+                            break
+                        pipe_steps.append(r_text)
+                        curr = curr.left
+                    l_text = ast.unparse(curr).strip() if hasattr(ast, "unparse") else ""
+                    if is_valid_pipe and l_text and not isinstance(curr, ast.Constant):
+                        pipe_steps.append(l_text)
+                        pipe_steps.reverse()
+                        if len(pipe_steps) >= 2:
+                            self.bindings.append(
+                                BindingRef(
+                                    target_name=target.id,
+                                    file_path=self.file_path,
+                                    line=node.lineno,
+                                    column=getattr(node, "col_offset", None),
+                                    scope=self.current_scope_qname or "",
+                                    expr_kind="LCEL_PIPELINE",
+                                    base_expr="|".join(pipe_steps),
+                                    source_expr=json.dumps(pipe_steps),
+                                )
+                            )
             elif (
                 isinstance(target, ast.Attribute)
                 and isinstance(target.value, ast.Name)
@@ -1575,6 +1623,39 @@ class _PythonScopeVisitor(ast.NodeVisitor):
         caller_canon = self.current_scope_canonical_id
         end_ln = node.end_lineno or node.lineno
 
+        # Python View -> Template rendering (Flask render_template, Django render, FastAPI TemplateResponse)
+        template_name: str | None = None
+        if isinstance(node.func, ast.Name):
+            if node.func.id == "render_template" and node.args:
+                if isinstance(node.args[0], ast.Constant) and isinstance(node.args[0].value, str):
+                    template_name = node.args[0].value
+            elif node.func.id == "render" and len(node.args) >= 2:
+                if isinstance(node.args[1], ast.Constant) and isinstance(node.args[1].value, str):
+                    template_name = node.args[1].value
+        elif isinstance(node.func, ast.Attribute):
+            if node.func.attr == "TemplateResponse" and node.args:
+                if isinstance(node.args[0], ast.Constant) and isinstance(node.args[0].value, str):
+                    template_name = node.args[0].value
+                elif len(node.args) >= 2 and isinstance(node.args[1], ast.Constant) and isinstance(node.args[1].value, str):
+                    template_name = node.args[1].value
+                for kw in node.keywords:
+                    if kw.arg in ("name", "template_name") and isinstance(kw.value, ast.Constant) and isinstance(kw.value.value, str):
+                        template_name = kw.value.value
+
+        if template_name:
+            self.bindings.append(
+                BindingRef(
+                    target_name=template_name,
+                    file_path=self.file_path,
+                    line=node.lineno,
+                    column=getattr(node, "col_offset", None),
+                    scope=caller_qname or "",
+                    expr_kind="RENDERS_TEMPLATE",
+                    base_expr=caller_canon or "",
+                    source_expr=template_name,
+                )
+            )
+
         if isinstance(node.func, ast.Name):
             callee_name = node.func.id
             if callee_name == "subscribe" and len(node.args) >= 2 and hasattr(ast, "unparse"):
@@ -2010,6 +2091,106 @@ class _PythonScopeVisitor(ast.NodeVisitor):
                             subscript_key=ev_str,
                         )
                     )
+            # Celery / Background task / Ray remote task invocation (.delay(), .apply_async(), .s(), .si(), .signature(), .remote())
+            if attr_name in ("delay", "apply_async", "s", "si", "signature", "remote"):
+                task_callee = recv_clean.split(".")[-1]
+                if task_callee and task_callee not in ("self", "cls"):
+                    self.calls.append(
+                        CallRef(
+                            callee=task_callee,
+                            qualified_callee=recv_clean,
+                            line=node.lineno,
+                            end_line=end_ln,
+                            source_file=self.file_path,
+                            confidence="HIGH",
+                            caller_symbol=caller_qname,
+                            caller_canonical_id=caller_canon,
+                            receiver=recv_clean if "." in recv_clean else None,
+                        )
+                    )
+                    dispatch_kind = "RAY_REMOTE" if attr_name == "remote" else "CELERY_DISPATCH"
+                    self.bindings.append(
+                        BindingRef(
+                            target_name=task_callee,
+                            file_path=self.file_path,
+                            line=node.lineno,
+                            column=getattr(node, "col_offset", None),
+                            scope=caller_qname or "",
+                            expr_kind=dispatch_kind,
+                            base_expr=attr_name,
+                            source_expr=recv_clean,
+                        )
+                    )
+            elif attr_name == "send_task" and node.args and isinstance(node.args[0], ast.Constant) and isinstance(node.args[0].value, str):
+                full_task = node.args[0].value
+                task_short = full_task.split(".")[-1]
+                self.calls.append(
+                    CallRef(
+                        callee=task_short,
+                        qualified_callee=full_task,
+                        line=node.lineno,
+                        end_line=end_ln,
+                        source_file=self.file_path,
+                        confidence="HIGH",
+                        caller_symbol=caller_qname,
+                        caller_canonical_id=caller_canon,
+                        receiver=full_task if "." in full_task else None,
+                    )
+                )
+                self.bindings.append(
+                    BindingRef(
+                        target_name=task_short,
+                        file_path=self.file_path,
+                        line=node.lineno,
+                        column=getattr(node, "col_offset", None),
+                        scope=caller_qname or "",
+                        expr_kind="CELERY_DISPATCH",
+                        base_expr="send_task",
+                        source_expr=full_task,
+                    )
+                )
+            elif attr_name == "connect" and node.args and hasattr(ast, "unparse"):
+                receiver_node = node.args[0]
+                receiver_name = ast.unparse(receiver_node).strip()
+                sender_name = ""
+                for kw in node.keywords:
+                    if kw.arg == "sender":
+                        if isinstance(kw.value, ast.Constant) and isinstance(kw.value.value, str):
+                            sender_name = kw.value.value
+                        elif isinstance(kw.value, (ast.Name, ast.Attribute)):
+                            sender_name = ast.unparse(kw.value).strip()
+                self.bindings.append(
+                    BindingRef(
+                        target_name=receiver_name,
+                        file_path=self.file_path,
+                        line=node.lineno,
+                        column=getattr(node, "col_offset", None),
+                        scope=self.current_scope_qname or "",
+                        expr_kind="DJANGO_SIGNAL_RECEIVER",
+                        base_expr=recv_clean,
+                        source_expr=sender_name,
+                    )
+                )
+            elif attr_name in ("send", "send_robust") and hasattr(ast, "unparse"):
+                sender_name = ""
+                for kw in node.keywords:
+                    if kw.arg == "sender":
+                        if isinstance(kw.value, ast.Constant) and isinstance(kw.value.value, str):
+                            sender_name = kw.value.value
+                        elif isinstance(kw.value, (ast.Name, ast.Attribute)):
+                            sender_name = ast.unparse(kw.value).strip()
+                self.bindings.append(
+                    BindingRef(
+                        target_name=recv_clean,
+                        file_path=self.file_path,
+                        line=node.lineno,
+                        column=getattr(node, "col_offset", None),
+                        scope=self.current_scope_qname or "",
+                        expr_kind="DJANGO_SIGNAL_SEND",
+                        base_expr=attr_name,
+                        source_expr=sender_name,
+                    )
+                )
 
             q_callee = f"{resolved_recv}.{attr_name}" if resolved_recv else attr_name
             self.calls.append(
@@ -2042,6 +2223,26 @@ class _PythonScopeVisitor(ast.NodeVisitor):
                 )
             )
 
+        # Agent tool registration (e.g. AgentExecutor(tools=[...]), create_openai_tools_agent(..., tools=[...]))
+        for kw in node.keywords:
+            if kw.arg in ("tools", "functions") and isinstance(kw.value, (ast.List, ast.Tuple)):
+                func_label = ast.unparse(node.func).strip() if hasattr(ast, "unparse") else ""
+                for elt in kw.value.elts:
+                    t_name = ast.unparse(elt).strip() if hasattr(ast, "unparse") else ""
+                    if t_name:
+                        self.bindings.append(
+                            BindingRef(
+                                target_name=t_name,
+                                file_path=self.file_path,
+                                line=node.lineno,
+                                column=getattr(node, "col_offset", None),
+                                scope=caller_qname or "",
+                                expr_kind="AGENT_TOOL_REGISTRATION",
+                                base_expr=func_label,
+                                source_expr=t_name,
+                            )
+                        )
+
         self.generic_visit(node)
 
 
@@ -3013,6 +3214,44 @@ def _parse_js_ts(content: str, language: str, file_path: str) -> ParseResult:
                     )
                 )
 
+    # Framework file-level enhancements (NestJS and Next.js)
+    if "@" in content:
+        nest_res = analyze_nestjs_file(content, file_path, module)
+        if nest_res.routes:
+            routes.extend(nest_res.routes)
+        if nest_res.mounts:
+            mounts.extend(nest_res.mounts)
+        if nest_res.bindings:
+            bindings.extend(nest_res.bindings)
+
+    next_res = analyze_nextjs_file(content, file_path, module)
+    if next_res.routes:
+        seen_ep_ids = {r.endpoint_id for r in routes}
+        for nr in next_res.routes:
+            if nr.endpoint_id not in seen_ep_ids:
+                routes.append(nr)
+                seen_ep_ids.add(nr.endpoint_id)
+    if next_res.bindings:
+        bindings.extend(next_res.bindings)
+
+    # React and JSX component architecture (Pillar 4)
+    react_res = analyze_react_file(content, file_path, module)
+    sym_indices = {s.canonical_id: i for i, s in enumerate(symbols)}
+    for sym in react_res.components:
+        if sym.canonical_id in sym_indices:
+            symbols[sym_indices[sym.canonical_id]] = sym
+        else:
+            seen_canonical.add(sym.canonical_id)
+            symbols.append(sym)
+    for h_sym in react_res.hooks:
+        if h_sym.canonical_id in sym_indices:
+            symbols[sym_indices[h_sym.canonical_id]] = h_sym
+        else:
+            seen_canonical.add(h_sym.canonical_id)
+            symbols.append(h_sym)
+    if react_res.bindings:
+        bindings.extend(react_res.bindings)
+
     symbols.sort(key=lambda s: (s.start_line, s.canonical_id))
     return ParseResult(
         path=file_path,

codegraph/indexing/pool.py

@@ -0,0 +1,136 @@
+"""Thread-safe SQLite connection pool for concurrent MCP and CLI execution."""
+from __future__ import annotations
+
+import queue
+import sqlite3
+import threading
+from collections.abc import Callable
+from pathlib import Path
+
+from .classifier import make_compat_row
+
+
+class SQLiteConnectionPool:
+    """Thread-safe, re-entrant connection pool for SQLite databases.
+
+    Features:
+    - Thread-safe LIFO pool to maximize SQLite cache reuse.
+    - WAL mode, synchronous=NORMAL, foreign_keys=ON, busy_timeout=30000ms.
+    - check_same_thread=False for cross-thread pool handoff.
+    - Re-entrant per-thread acquisition (nesting depth tracking via thread-local state).
+    - Optional initializer hook for idempotent schema / setup execution.
+    """
+
+    def __init__(
+        self,
+        db_path: Path | str,
+        max_size: int = 16,
+        timeout: float = 30.0,
+        initializer: Callable[[sqlite3.Connection], None] | None = None,
+    ) -> None:
+        self.db_path = Path(db_path) if isinstance(db_path, str) else db_path
+        self.max_size = max(1, max_size)
+        self.timeout = timeout
+        self.initializer = initializer
+        self._pool: queue.LifoQueue[sqlite3.Connection] = queue.LifoQueue()
+        self._created = 0
+        self._lock = threading.Lock()
+        self._local = threading.local()
+
+    def _create_connection(self) -> sqlite3.Connection:
+        con = sqlite3.connect(
+            self.db_path,
+            check_same_thread=False,
+            timeout=self.timeout,
+        )
+        con.row_factory = make_compat_row
+        con.execute("PRAGMA journal_mode = WAL")
+        con.execute("PRAGMA synchronous = NORMAL")
+        con.execute("PRAGMA foreign_keys = ON")
+        con.execute("PRAGMA busy_timeout = 30000")
+        con.execute("PRAGMA cache_size = -64000")
+        con.execute("PRAGMA temp_store = MEMORY")
+        if self.initializer is not None:
+            self.initializer(con)
+        return con
+
+    def acquire(self) -> tuple[sqlite3.Connection, bool]:
+        """Acquire a connection. Returns (connection, is_owner).
+
+        If the current thread already holds a connection from this pool,
+        it increments the re-entrancy depth and returns (connection, False).
+        """
+        active_con = getattr(self._local, "con", None)
+        if active_con is not None:
+            self._local.nesting = getattr(self._local, "nesting", 0) + 1
+            return active_con, False
+
+        con: sqlite3.Connection | None = None
+        try:
+            con = self._pool.get_nowait()
+        except queue.Empty:
+            with self._lock:
+                if self._created < self.max_size:
+                    con = self._create_connection()
+                    self._created += 1
+
+            if con is None:
+                con = self._pool.get(timeout=self.timeout)
+
+        self._local.con = con
+        self._local.nesting = 1
+        return con, True
+
+    def release(
+        self,
+        con: sqlite3.Connection,
+        is_owner: bool,
+        rollback: bool = False,
+    ) -> None:
+        """Release a connection back to the pool."""
+        if not is_owner:
+            cur_nesting = getattr(self._local, "nesting", 1) - 1
+            self._local.nesting = max(0, cur_nesting)
+            if rollback:
+                try:
+                    con.rollback()
+                except Exception:
+                    pass
+            return
+
+        self._local.con = None
+        self._local.nesting = 0
+        if rollback:
+            try:
+                con.rollback()
+            except Exception:
+                pass
+        else:
+            try:
+                con.commit()
+            except Exception:
+                pass
+
+        try:
+            self._pool.put_nowait(con)
+        except Exception:
+            try:
+                con.close()
+            except Exception:
+                pass
+
+    def close_all(self) -> None:
+        """Close and dispose all connections in the pool."""
+        with self._lock:
+            while True:
+                try:
+                    con = self._pool.get_nowait()
+                    try:
+                        con.close()
+                    except Exception:
+                        pass
+                except queue.Empty:
+                    break
+            self._created = 0
+            self._local.con = None
+            self._local.nesting = 0

codegraph/indexing/scanner.py

@@ -43,6 +43,12 @@ LANGUAGES = {
     ".tsx": "typescript",
     ".sql": "sql",
     ".prisma": "prisma",
+    ".html": "html",
+    ".htm": "html",
+    ".jinja": "html",
+    ".jinja2": "html",
+    ".njk": "html",
+    ".ejs": "html",
 }