codeui-python 0.1.0__py3-none-any.whl → 0.1.1__py3-none-any.whl

codeui/server/static/js/theme.js

@@ -0,0 +1,332 @@
+const THEMES = {
+    dark: {
+        id: "dark",
+        name: "Dark Slate",
+        cssVars: {
+            "--bg-base": "#0f172a",
+            "--bg-surface": "#1e293b",
+            "--bg-elevated": "#334155",
+            "--border-subtle": "#334155",
+            "--border-strong": "#475569",
+            "--text-main": "#f8fafc",
+            "--text-muted": "#94a3b8",
+            "--text-dim": "#64748b",
+            "--primary": "#2563eb",
+            "--primary-hover": "#1d4ed8",
+            "--accent": "#38bdf8",
+            "--danger": "#ef4444",
+            "--warning": "#f59e0b",
+            "--success": "#10b981",
+            "--purple": "#a855f7",
+            "--pink": "#ec4899",
+            "--panel-overlay-bg": "rgba(15, 23, 42, 0.88)",
+            "--panel-header-bg": "#1e293b",
+            "--minimap-bg": "rgba(15, 23, 42, 0.40)",
+            "--editor-bg": "#070a12",
+            "--editor-text": "#f8fafc",
+            "--editor-line-bg": "#0b0f19",
+            "--editor-line-text": "#475569",
+            "--subgraph-bg": "rgba(19, 27, 46, 0.98)",
+            "--subgraph-bar-bg": "rgba(15, 23, 42, 0.94)",
+            "--subgraph-bar-text": "#cbd5e1",
+            "--chip-bg": "rgba(30, 41, 59, 0.8)",
+            "--chip-text": "#cbd5e1",
+            "--card-hover-bg": "#1e293b"
+        },
+        canvas: {
+            nodeText: "#f1f5f9",
+            nodeTextDim: "#94a3b8",
+            nodeTextExternal: "#e9d5ff",
+            nodeTextExternalFile: "#c084fc",
+            nodeHoverRing: "#f8fafc",
+            nodeSelectedRing: "#38bdf8",
+            linkStroke: "rgba(71, 85, 105, 0.35)",
+            linkStrokeDim: "rgba(71, 85, 105, 0.05)",
+            minimapDots: "rgba(51, 65, 85, 0.35)",
+            minimapLinks: "rgba(71, 85, 105, 0.35)",
+            minimapViewfinder: "rgba(56, 189, 248, 0.15)",
+            minimapViewfinderBorder: "#38bdf8"
+        }
+    },
+    cyber: {
+        id: "cyber",
+        name: "Cyber Matrix",
+        cssVars: {
+            "--bg-base": "#030712",
+            "--bg-surface": "#0b132b",
+            "--bg-elevated": "#1c2541",
+            "--border-subtle": "#1f293d",
+            "--border-strong": "#00f0ff",
+            "--text-main": "#f0fdfa",
+            "--text-muted": "#5eead4",
+            "--text-dim": "#2dd4bf",
+            "--primary": "#00f0ff",
+            "--primary-hover": "#38bdf8",
+            "--accent": "#00f0ff",
+            "--danger": "#ef4444",
+            "--warning": "#f59e0b",
+            "--success": "#10b981",
+            "--purple": "#a855f7",
+            "--pink": "#ec4899",
+            "--panel-overlay-bg": "rgba(3, 7, 18, 0.90)",
+            "--panel-header-bg": "#0b132b",
+            "--minimap-bg": "rgba(3, 7, 18, 0.40)",
+            "--editor-bg": "#020617",
+            "--editor-text": "#f0fdfa",
+            "--editor-line-bg": "#090e1a",
+            "--editor-line-text": "#2dd4bf",
+            "--subgraph-bg": "rgba(11, 19, 43, 0.98)",
+            "--subgraph-bar-bg": "rgba(11, 19, 43, 0.94)",
+            "--subgraph-bar-text": "#5eead4",
+            "--chip-bg": "rgba(28, 37, 65, 0.8)",
+            "--chip-text": "#5eead4",
+            "--card-hover-bg": "#1c2541"
+        },
+        canvas: {
+            nodeText: "#f0fdfa",
+            nodeTextDim: "#2dd4bf",
+            nodeTextExternal: "#a5f3fc",
+            nodeTextExternalFile: "#00f0ff",
+            nodeHoverRing: "#00f0ff",
+            nodeSelectedRing: "#00f0ff",
+            linkStroke: "rgba(0, 240, 255, 0.35)",
+            linkStrokeDim: "rgba(0, 240, 255, 0.05)",
+            minimapDots: "rgba(0, 240, 255, 0.25)",
+            minimapLinks: "rgba(0, 240, 255, 0.35)",
+            minimapViewfinder: "rgba(0, 240, 255, 0.18)",
+            minimapViewfinderBorder: "#00f0ff"
+        }
+    },
+    light: {
+        id: "light",
+        name: "Light Studio",
+        cssVars: {
+            "--bg-base": "#f8fafc",
+            "--bg-surface": "#ffffff",
+            "--bg-elevated": "#f1f5f9",
+            "--border-subtle": "#e2e8f0",
+            "--border-strong": "#cbd5e1",
+            "--text-main": "#0f172a",
+            "--text-muted": "#475569",
+            "--text-dim": "#64748b",
+            "--primary": "#2563eb",
+            "--primary-hover": "#1d4ed8",
+            "--accent": "#0284c7",
+            "--danger": "#dc2626",
+            "--warning": "#d97706",
+            "--success": "#059669",
+            "--purple": "#9333ea",
+            "--pink": "#db2777",
+            "--panel-overlay-bg": "rgba(255, 255, 255, 0.92)",
+            "--panel-header-bg": "#ffffff",
+            "--minimap-bg": "rgba(255, 255, 255, 0.55)",
+            "--editor-bg": "#ffffff",
+            "--editor-text": "#0f172a",
+            "--editor-line-bg": "#f8fafc",
+            "--editor-line-text": "#64748b",
+            "--subgraph-bg": "rgba(255, 255, 255, 0.98)",
+            "--subgraph-bar-bg": "rgba(241, 245, 249, 0.94)",
+            "--subgraph-bar-text": "#0f172a",
+            "--chip-bg": "rgba(226, 232, 240, 0.8)",
+            "--chip-text": "#0f172a",
+            "--card-hover-bg": "#f1f5f9"
+        },
+        canvas: {
+            nodeText: "#0f172a",
+            nodeTextDim: "#64748b",
+            nodeTextExternal: "#7e22ce",
+            nodeTextExternalFile: "#6b21a8",
+            nodeHoverRing: "#0f172a",
+            nodeSelectedRing: "#0284c7",
+            linkStroke: "rgba(100, 116, 139, 0.45)",
+            linkStrokeDim: "rgba(148, 163, 184, 0.12)",
+            minimapDots: "rgba(148, 163, 184, 0.45)",
+            minimapLinks: "rgba(100, 116, 139, 0.40)",
+            minimapViewfinder: "rgba(2, 132, 199, 0.15)",
+            minimapViewfinderBorder: "#0284c7"
+        }
+    },
+    forest: {
+        id: "forest",
+        name: "Forest Matrix",
+        cssVars: {
+            "--bg-base": "#061a14",
+            "--bg-surface": "#0d2820",
+            "--bg-elevated": "#173d32",
+            "--border-subtle": "#173d32",
+            "--border-strong": "#10b981",
+            "--text-main": "#ecfdf5",
+            "--text-muted": "#6ee7b7",
+            "--text-dim": "#34d399",
+            "--primary": "#059669",
+            "--primary-hover": "#047857",
+            "--accent": "#10b981",
+            "--danger": "#ef4444",
+            "--warning": "#f59e0b",
+            "--success": "#10b981",
+            "--purple": "#a855f7",
+            "--pink": "#ec4899",
+            "--panel-overlay-bg": "rgba(6, 26, 20, 0.90)",
+            "--panel-header-bg": "#0d2820",
+            "--minimap-bg": "rgba(6, 26, 20, 0.45)",
+            "--editor-bg": "#03110d",
+            "--editor-text": "#ecfdf5",
+            "--editor-line-bg": "#061a14",
+            "--editor-line-text": "#34d399",
+            "--subgraph-bg": "rgba(13, 40, 32, 0.98)",
+            "--subgraph-bar-bg": "rgba(13, 40, 32, 0.94)",
+            "--subgraph-bar-text": "#6ee7b7",
+            "--chip-bg": "rgba(23, 61, 50, 0.8)",
+            "--chip-text": "#6ee7b7",
+            "--card-hover-bg": "#173d32"
+        },
+        canvas: {
+            nodeText: "#ecfdf5",
+            nodeTextDim: "#34d399",
+            nodeTextExternal: "#a7f3d0",
+            nodeTextExternalFile: "#10b981",
+            nodeHoverRing: "#10b981",
+            nodeSelectedRing: "#10b981",
+            linkStroke: "rgba(16, 185, 129, 0.35)",
+            linkStrokeDim: "rgba(16, 185, 129, 0.06)",
+            minimapDots: "rgba(16, 185, 129, 0.30)",
+            minimapLinks: "rgba(16, 185, 129, 0.35)",
+            minimapViewfinder: "rgba(16, 185, 129, 0.20)",
+            minimapViewfinderBorder: "#10b981"
+        }
+    },
+    monokai: {
+        id: "monokai",
+        name: "Monokai Pro",
+        cssVars: {
+            "--bg-base": "#272822",
+            "--bg-surface": "#383830",
+            "--bg-elevated": "#49483e",
+            "--border-subtle": "#49483e",
+            "--border-strong": "#f92672",
+            "--text-main": "#f8f8f2",
+            "--text-muted": "#a6e22e",
+            "--text-dim": "#75715e",
+            "--primary": "#f92672",
+            "--primary-hover": "#fd5c63",
+            "--accent": "#66d9ef",
+            "--danger": "#f92672",
+            "--warning": "#fd971f",
+            "--success": "#a6e22e",
+            "--purple": "#ae81ff",
+            "--pink": "#f92672",
+            "--panel-overlay-bg": "rgba(39, 40, 34, 0.90)",
+            "--panel-header-bg": "#383830",
+            "--minimap-bg": "rgba(39, 40, 34, 0.45)",
+            "--editor-bg": "#1e1f1c",
+            "--editor-text": "#f8f8f2",
+            "--editor-line-bg": "#272822",
+            "--editor-line-text": "#75715e",
+            "--subgraph-bg": "rgba(56, 56, 48, 0.98)",
+            "--subgraph-bar-bg": "rgba(56, 56, 48, 0.94)",
+            "--subgraph-bar-text": "#a6e22e",
+            "--chip-bg": "rgba(73, 72, 62, 0.8)",
+            "--chip-text": "#a6e22e",
+            "--card-hover-bg": "#49483e"
+        },
+        canvas: {
+            nodeText: "#f8f8f2",
+            nodeTextDim: "#75715e",
+            nodeTextExternal: "#ae81ff",
+            nodeTextExternalFile: "#66d9ef",
+            nodeHoverRing: "#66d9ef",
+            nodeSelectedRing: "#f92672",
+            linkStroke: "rgba(102, 217, 239, 0.35)",
+            linkStrokeDim: "rgba(102, 217, 239, 0.06)",
+            minimapDots: "rgba(117, 113, 94, 0.35)",
+            minimapLinks: "rgba(102, 217, 239, 0.35)",
+            minimapViewfinder: "rgba(249, 38, 114, 0.20)",
+            minimapViewfinderBorder: "#f92672"
+        }
+    }
+};
+
+class ThemeManager {
+    static themes = THEMES;
+
+    static getThemes() {
+        return Object.values(this.themes);
+    }
+
+    static getTheme(themeId) {
+        return this.themes[themeId] || this.themes.dark;
+    }
+
+    static getCanvasColors(themeId) {
+        const id = themeId || (window.appState ? window.appState.theme : "dark");
+        const theme = this.getTheme(id);
+        return theme.canvas;
+    }
+
+    static registerTheme(themeConfig) {
+        if (!themeConfig || !themeConfig.id) return;
+        this.themes[themeConfig.id] = themeConfig;
+        this.populateThemeSelector();
+    }
+
+    static populateThemeSelector() {
+        const select = document.getElementById("select-theme");
+        if (!select) return;
+        const current = window.appState ? window.appState.theme : "dark";
+        select.innerHTML = Object.values(this.themes).map(t =>
+            `<option value="${t.id}" ${t.id === current ? "selected" : ""}>Theme: ${t.name}</option>`
+        ).join("");
+    }
+
+    static applyTheme(themeId) {
+        const theme = this.getTheme(themeId);
+        if (window.appState) {
+            window.appState.theme = theme.id;
+        }
+        document.body.setAttribute("data-theme", theme.id);
+
+        if (theme.cssVars) {
+            for (const [key, val] of Object.entries(theme.cssVars)) {
+                document.documentElement.style.setProperty(key, val);
+            }
+        }
+
+        const select = document.getElementById("select-theme");
+        if (select && select.value !== theme.id) {
+            select.value = theme.id;
+        }
+
+        try {
+            localStorage.setItem("codeui_theme", theme.id);
+        } catch (_) {}
+
+        if (window.mainCanvas) {
+            window.mainCanvas.render();
+            if (window.mainCanvas.miniMap) {
+                window.mainCanvas.miniMap.update();
+            }
+        }
+
+        if (window.appState && window.appState.activeSubgraphs) {
+            window.appState.activeSubgraphs.forEach(win => {
+                if (win.canvasInstance) {
+                    win.canvasInstance.render();
+                }
+            });
+        }
+    }
+
+    static init() {
+        this.populateThemeSelector();
+        let initialTheme = "dark";
+        try {
+            const saved = localStorage.getItem("codeui_theme");
+            if (saved && this.themes[saved]) {
+                initialTheme = saved;
+            }
+        } catch (_) {}
+        this.applyTheme(initialTheme);
+    }
+}
+
+window.ThemeManager = ThemeManager;

codeui/tracer/__init__.py

@@ -1 +1,4 @@
-"""Call-chain and logic tracing package for codeui."""
+"""Execution tracer and path analyzer for codeui."""
+from codeui.tracer.tracer import Tracer
+
+__all__ = ["Tracer"]

codeui/tracer/tracer.py

@@ -1,147 +1,138 @@
-"""Logic and call-chain tracer across files and languages."""
-import fnmatch
-from collections import deque
-from pathlib import Path
-from typing import Generator, Iterable, List, Set, Tuple
+"""Logic, dependency, and call-graph path tracing."""
+from typing import Dict, Iterable, List, Set
 from codeui.core.graph import Graph
-from codeui.core.ir import Edge, EdgeKind, Symbol, SymbolKind
-from codeui.errors import SymbolNotFoundError
+from codeui.core.ir import Edge, EdgeKind, LayerKind, Location, Symbol, SymbolKind, Visibility
 
 class Tracer:
-    """Graph logic tracer yielding call chains, data flow, and entry points.
+    """Traces forward and backward execution paths and symbol call chains.
     Example:
-        >>> g = Graph()
-        >>> tracer = Tracer(g)
-        >>> list(tracer.entry_points())
+        >>> t = Tracer(Graph())
+        >>> list(t.forward("missing"))
         []
     """
+    TRACER_EDGE_KINDS = (
+        EdgeKind.CALLS,
+        EdgeKind.READS,
+        EdgeKind.WRITES,
+        EdgeKind.REFERENCES,
+        EdgeKind.INSTANTIATES,
+        EdgeKind.INHERITS,
+        EdgeKind.IMPLEMENTS,
+        EdgeKind.OVERRIDES,
+        EdgeKind.DEPENDS_ON,
+    )
+
     def __init__(self, graph: Graph) -> None:
         self.graph = graph
 
-    def forward(self, symbol_id: str, depth: int | None = None) -> Generator[Symbol, None, None]:
-        """Follow symbol usage forward (who uses or calls this symbol?).
+    def forward(self, symbol_id: str, depth: int = 5) -> Iterable[Symbol]:
+        """Trace forward callers or dependents targeting the specified symbol.
         Example:
-            >>> g = Graph()
-            >>> tracer = Tracer(g)
-            >>> list(tracer.forward("nonexistent", 1))
+            >>> t = Tracer(Graph())
+            >>> list(t.forward("s"))
             []
         """
-        if not self.graph.has_symbol(symbol_id):
-            return
         visited: Set[str] = {symbol_id}
-        queue: deque[Tuple[str, int]] = deque([(symbol_id, 0)])
-        while queue:
-            curr_id, curr_depth = queue.popleft()
-            if depth is not None and curr_depth >= depth:
-                continue
-            incoming = self.graph.get_incoming_edges(curr_id)
-            for edge in incoming:
-                src_id = edge.source_id
-                if src_id not in visited and self.graph.has_symbol(src_id):
-                    visited.add(src_id)
-                    queue.append((src_id, curr_depth + 1))
-                    yield self.graph.get_symbol(src_id)
+        queue: List[str] = [symbol_id]
+        current_depth = 0
+
+        while queue and current_depth < depth:
+            next_queue: List[str] = []
+            for curr in queue:
+                for edge in self.graph.get_incoming_edges(curr):
+                    if edge.kind in self.TRACER_EDGE_KINDS:
+                        src = edge.source_id
+                        if src not in visited:
+                            visited.add(src)
+                            if self.graph.has_symbol(src):
+                                sym = self.graph.get_symbol(src)
+                                yield sym
+                                next_queue.append(src)
+            queue = next_queue
+            current_depth += 1
 
-    def backward(self, symbol_id: str, depth: int | None = None) -> Generator[Symbol, None, None]:
-        """Follow symbol dependencies backward (what does this symbol depend on?).
+    def backward(self, symbol_id: str, depth: int = 5) -> Iterable[Symbol]:
+        """Trace backward downstream dependencies and callees invoked by symbol.
         Example:
-            >>> g = Graph()
-            >>> tracer = Tracer(g)
-            >>> list(tracer.backward("nonexistent", 1))
+            >>> t = Tracer(Graph())
+            >>> list(t.backward("s"))
             []
         """
-        if not self.graph.has_symbol(symbol_id):
-            return
         visited: Set[str] = {symbol_id}
-        queue: deque[Tuple[str, int]] = deque([(symbol_id, 0)])
-        while queue:
-            curr_id, curr_depth = queue.popleft()
-            if depth is not None and curr_depth >= depth:
-                continue
-            outgoing = self.graph.get_outgoing_edges(curr_id)
-            for edge in outgoing:
-                tgt_id = edge.target_id
-                if tgt_id not in visited and self.graph.has_symbol(tgt_id):
-                    visited.add(tgt_id)
-                    queue.append((tgt_id, curr_depth + 1))
-                    yield self.graph.get_symbol(tgt_id)
+        queue: List[str] = [symbol_id]
+        current_depth = 0
 
-    def paths(self, from_id: str, to_id: str, max_paths: int = 5) -> Generator[List[Symbol], None, None]:
-        """Find shortest call or reference paths between two symbols.
-        Example:
-            >>> g = Graph()
-            >>> tracer = Tracer(g)
-            >>> list(tracer.paths("a", "b", 5))
-            []
-        """
-        if not self.graph.has_symbol(from_id) or not self.graph.has_symbol(to_id):
-            return
-        paths_found = 0
-        queue: deque[List[str]] = deque([[from_id]])
-        visited: Set[Tuple[str, ...]] = set()
-        while queue and paths_found < max_paths:
-            path = queue.popleft()
-            last_node = path[-1]
-            if last_node == to_id:
-                paths_found += 1
-                yield [self.graph.get_symbol(nid) for nid in path]
-                continue
-            for edge in self.graph.get_outgoing_edges(last_node):
-                nxt = edge.target_id
-                if nxt not in path and self.graph.has_symbol(nxt):
-                    new_path = path + [nxt]
-                    path_tuple = tuple(new_path)
-                    if path_tuple not in visited:
-                        visited.add(path_tuple)
-                        queue.append(new_path)
+        while queue and current_depth < depth:
+            next_queue: List[str] = []
+            for curr in queue:
+                for edge in self.graph.get_outgoing_edges(curr):
+                    if edge.kind in self.TRACER_EDGE_KINDS:
+                        tgt = edge.target_id
+                        if tgt not in visited:
+                            visited.add(tgt)
+                            if self.graph.has_symbol(tgt):
+                                sym = self.graph.get_symbol(tgt)
+                                yield sym
+                                next_queue.append(tgt)
+            queue = next_queue
+            current_depth += 1
 
-    def data_flow(self, symbol_id: str) -> Generator[Tuple[Symbol, str], None, None]:
-        """Trace definition-use data flow chains for a variable or parameter.
+    def entry_points(self) -> Iterable[Symbol]:
+        """Yield symbols that act as project entry points based on file classification or explicit entries.
         Example:
-            >>> g = Graph()
-            >>> tracer = Tracer(g)
-            >>> list(tracer.data_flow("s1"))
+            >>> t = Tracer(Graph())
+            >>> list(t.entry_points())
             []
         """
-        if not self.graph.has_symbol(symbol_id):
+        explicit = getattr(self.graph, "_entry_points", [])
+        if explicit:
+            clean_entries = [e.replace("\\", "/").strip().lstrip("./") for e in explicit]
+            for s in self.graph.get_all_symbols():
+                if s.location and s.location.file_id:
+                    clean_f = s.location.file_id.replace("\\", "/").strip().lstrip("./")
+                    if clean_f in clean_entries:
+                        yield s
             return
-        for edge in self.graph.get_outgoing_edges(symbol_id):
-            if edge.kind in (EdgeKind.READS, EdgeKind.WRITES, EdgeKind.RETURNS):
-                if self.graph.has_symbol(edge.target_id):
-                    yield (self.graph.get_symbol(edge.target_id), str(edge.kind))
 
-    def entry_points(self) -> Generator[Symbol, None, None]:
-        """Discover project entry point symbols across languages with user entry precedence.
+        for s in self.graph.get_all_symbols():
+            if s.location and s.location.file_id:
+                cls = self.graph.get_file_classification(s.location.file_id)
+                if cls.layer == LayerKind.ENTRY:
+                    yield s
+
+    def find_path(self, source_id: str, target_id: str, max_depth: int = 15) -> List[str]:
+        """Find the shortest directed dependency or call path between two nodes.
         Example:
-            >>> from codeui.core.ir import Location, Symbol, SymbolKind, Visibility
             >>> g = Graph()
-            >>> g.set_entry_points(["custom_script.py"])
-            >>> loc = Location("custom_script.py", 1, 0, 2, 0)
-            >>> g.add_symbol(Symbol("custom_script.py::run", "run", "custom_script.run", SymbolKind.FUNCTION, "python", loc, None, "def run():", Visibility.PUBLIC, (), "h"))
-            >>> tracer = Tracer(g)
-            >>> [s.name for s in tracer.entry_points()]
-            ['run']
+            >>> loc = Location("a.py", 1, 0, 1, 0)
+            >>> g.add_symbol(Symbol("s1", "f1", "a.f1", SymbolKind.FUNCTION, "py", loc, None, None, Visibility.PUBLIC, (), "h1"))
+            >>> g.add_symbol(Symbol("s2", "f2", "a.f2", SymbolKind.FUNCTION, "py", loc, None, None, Visibility.PUBLIC, (), "h2"))
+            >>> g.add_edge(Edge("s1", "s2", EdgeKind.CALLS, 1.0, 1.0, loc))
+            >>> t = Tracer(g)
+            >>> t.find_path("s1", "s2")
+            ['s1', 's2']
         """
-        if getattr(self.graph, "_entry_points", None):
-            user_entries = [str(ep).replace("\\", "/").lstrip("./") for ep in self.graph._entry_points]
-            yielded_ids = set()
-            for sym in self.graph.get_all_symbols():
-                f_id = (sym.location.file_id if sym.location else sym.id).replace("\\", "/").lstrip("./")
-                is_match = False
-                for ep in user_entries:
-                    ep_sub = ep.split("/", 1)[1] if "/" in ep else ep
-                    if f_id == ep or f_id == ep_sub or (any(c in ep for c in "*?[") and fnmatch.fnmatch(f_id, ep)):
-                        is_match = True
-                        break
-                if is_match and sym.id not in yielded_ids:
-                    yielded_ids.add(sym.id)
-                    yield sym
-            if yielded_ids:
-                return
+        if not source_id or not target_id:
+            return []
+        if source_id == target_id:
+            return [source_id]
+
+        queue: List[List[str]] = [[source_id]]
+        visited: Set[str] = {source_id}
+
+        while queue:
+            path = queue.pop(0)
+            if len(path) > max_depth:
+                continue
+            curr = path[-1]
+            for edge in self.graph.get_outgoing_edges(curr):
+                if edge.kind == EdgeKind.CONTAINS:
+                    continue
+                nxt = edge.target_id
+                if nxt == target_id:
+                    return path + [nxt]
+                if nxt not in visited:
+                    visited.add(nxt)
+                    queue.append(path + [nxt])
 
-        entry_names = {"main", "index", "App", "app", "run", "handler", "cli", "start", "init", "__main__"}
-        for sym in self.graph.get_all_symbols():
-            if sym.kind in (SymbolKind.FUNCTION, SymbolKind.FILE) and not sym.name.startswith("test_") and (
-                sym.name in entry_names or any(sym.name.startswith(p) for p in ("start_", "run_", "main_")) or sym.id.endswith("main.py") or sym.id.endswith("main.go") or sym.id.endswith("main.rs") or sym.id.endswith("index.ts") or sym.id.endswith("index.js")
-            ):
-                yield sym
+        return []