gopeak 2.1.0 → 2.2.1

package/build/visualizer/state.js

@@ -0,0 +1,210 @@
+/**
+ * Shared state and constants for the visualizer
+ */
+// Project data injected at build time
+export const PROJECT_DATA = "%%PROJECT_DATA%%";
+// Node dimensions
+export const NODE_W = 200;
+export const NODE_H = 54;
+// Camera state
+export const camera = { x: 0, y: 0, zoom: 1 };
+export let defaultZoom = 1;
+export function setDefaultZoom(value) {
+    defaultZoom = value;
+}
+// Viewport dimensions
+export let W = 0;
+export let H = 0;
+export function setDimensions(width, height) {
+    W = width;
+    H = height;
+}
+// Interaction state
+export let dragging = null;
+export let hoveredNode = null;
+export let selectedNode = null;
+export let searchTerm = '';
+export function setDragging(value) {
+    dragging = value;
+}
+export function setHoveredNode(value) {
+    hoveredNode = value;
+}
+export function setSelectedNode(value) {
+    selectedNode = value;
+}
+export function setSearchTerm(value) {
+    searchTerm = value;
+}
+// Folder color mapping
+const FOLDER_COLORS = [
+    '#d4a27f', '#7aa2f7', '#a6e3a1', '#f38ba8', '#89dceb',
+    '#fab387', '#cba6f7', '#f9e2af', '#94e2d5', '#eba0ac'
+];
+const folderColorMap = {};
+let folderColorIdx = 0;
+export function getFolderColor(folder) {
+    if (!folder)
+        return FOLDER_COLORS[0];
+    if (!folderColorMap[folder]) {
+        folderColorMap[folder] = FOLDER_COLORS[folderColorIdx % FOLDER_COLORS.length];
+        folderColorIdx++;
+    }
+    return folderColorMap[folder];
+}
+export const categories = PROJECT_DATA.categories || [];
+export const categoryColorMap = {};
+categories.forEach(c => {
+    categoryColorMap[c.id] = c.color;
+});
+// Initialize nodes from project data
+export const nodes = PROJECT_DATA.nodes.map((n, i) => ({
+    ...n,
+    x: 0,
+    y: 0,
+    color: categoryColorMap[n.category] || getFolderColor(n.folder),
+    highlighted: true,
+    visible: true,
+    categoryVisible: true
+}));
+export const edges = PROJECT_DATA.edges;
+export let categoryGroupMode = 'free';
+export function setCategoryGroupMode(mode) {
+    categoryGroupMode = mode;
+}
+export const activeCategories = new Set(categories.map(c => c.id));
+export function toggleCategory(categoryId) {
+    if (activeCategories.has(categoryId)) {
+        activeCategories.delete(categoryId);
+    }
+    else {
+        activeCategories.add(categoryId);
+    }
+    updateNodeVisibility();
+}
+export function setAllCategories(active) {
+    activeCategories.clear();
+    if (active) {
+        categories.forEach(c => {
+            activeCategories.add(c.id);
+        });
+    }
+    updateNodeVisibility();
+}
+function updateNodeVisibility() {
+    nodes.forEach(n => {
+        n.categoryVisible = activeCategories.has(n.category || 'other');
+    });
+}
+updateNodeVisibility();
+// ── Git Changes state ──
+export let changesVisible = true;
+export function setChangesVisible(value) {
+    changesVisible = value;
+}
+export const actionLog = [];
+const MAX_ACTION_LOG = 100;
+export function addActionEntry(entry) {
+    actionLog.push(entry);
+    if (actionLog.length > MAX_ACTION_LOG)
+        actionLog.shift();
+}
+export const gitChangeSummary = { modified: 0, added: 0, untracked: 0, new: 0 };
+// Compute summary from project data
+nodes.forEach(n => {
+    if (n.gitStatus === 'modified')
+        gitChangeSummary.modified++;
+    else if (n.gitStatus === 'added')
+        gitChangeSummary.added++;
+    else if (n.gitStatus === 'untracked')
+        gitChangeSummary.untracked++;
+});
+export let changesFilter = null; // null = show all, or 'modified' | 'added' | 'untracked'
+export function setChangesFilter(type) {
+    changesFilter = type;
+}
+// View state
+export let currentView = 'scripts';
+export let sceneData = null;
+// Scene view state
+export let expandedScene = null; // The scene currently expanded (path)
+export let expandedSceneHierarchy = null; // Full hierarchy of expanded scene
+export let selectedSceneNode = null; // Currently selected node in scene tree
+export let hoveredSceneNode = null; // Node being hovered over
+export let sceneNodeProperties = null; // Properties of selected scene node
+// Scene positions (for scene cards in overview)
+export const scenePositions = {};
+export function setCurrentView(view) {
+    currentView = view;
+    // Clear scene-specific state when switching views
+    if (view === 'scripts') {
+        expandedScene = null;
+        expandedSceneHierarchy = null;
+        selectedSceneNode = null;
+        hoveredSceneNode = null;
+        sceneNodeProperties = null;
+    }
+}
+// Script to scenes mapping (which scripts are used in which scenes)
+export const scriptToScenes = {};
+export function setSceneData(data) {
+    sceneData = data;
+    // Build script-to-scenes mapping
+    for (const key in scriptToScenes) {
+        delete scriptToScenes[key];
+    }
+    if (data && data.scenes) {
+        for (const scene of data.scenes) {
+            const sceneName = scene.name || scene.path.split('/').pop().replace('.tscn', '');
+            if (scene.scripts) {
+                for (const scriptPath of scene.scripts) {
+                    if (!scriptToScenes[scriptPath]) {
+                        scriptToScenes[scriptPath] = [];
+                    }
+                    scriptToScenes[scriptPath].push({
+                        path: scene.path,
+                        name: sceneName
+                    });
+                }
+            }
+        }
+    }
+}
+export function setExpandedScene(scenePath) {
+    expandedScene = scenePath;
+    if (!scenePath) {
+        expandedSceneHierarchy = null;
+        selectedSceneNode = null;
+        hoveredSceneNode = null;
+        sceneNodeProperties = null;
+    }
+}
+export function setExpandedSceneHierarchy(hierarchy) {
+    expandedSceneHierarchy = hierarchy;
+}
+export function setSelectedSceneNode(node) {
+    selectedSceneNode = node;
+    sceneNodeProperties = null; // Clear until loaded
+}
+export function setHoveredSceneNode(node) {
+    hoveredSceneNode = node;
+}
+export function setSceneNodeProperties(props) {
+    sceneNodeProperties = props;
+}
+export function setScenePosition(scenePath, x, y) {
+    scenePositions[scenePath] = { x, y };
+}
+// Delete operation state
+export let pendingDelete = null;
+export let currentUsages = [];
+export function setPendingDelete(value) {
+    pendingDelete = value;
+}
+export function setCurrentUsages(value) {
+    currentUsages = value;
+}
+// Utility function
+export function esc(s) {
+    return String(s || '').replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
+}

package/build/visualizer/syntax.js

@@ -0,0 +1,106 @@
+/**
+ * GDScript syntax highlighting (Godot 4 colors)
+ * Uses a tokenizer approach to avoid regex conflicts
+ */
+const GD_KEYWORDS = new Set([
+    'var', 'func', 'signal', 'class_name', 'extends', 'class', 'enum', 'const',
+    'if', 'elif', 'else', 'for', 'while', 'match', 'break', 'continue', 'pass', 'return',
+    'and', 'or', 'not', 'in', 'is', 'as', 'self', 'super', 'true', 'false', 'null',
+    'void', 'await', 'yield', 'static', 'preload', 'load'
+]);
+const GD_TYPES = new Set([
+    'int', 'float', 'bool', 'String', 'Vector2', 'Vector3', 'Vector4',
+    'Color', 'Array', 'Dictionary', 'Object', 'Node', 'Node2D', 'Node3D',
+    'Control', 'Resource', 'Variant', 'void'
+]);
+export function highlightGDScript(code) {
+    const tokens = [];
+    let i = 0;
+    while (i < code.length) {
+        const ch = code[i];
+        const rest = code.slice(i);
+        // Comments
+        if (ch === '#') {
+            const end = code.indexOf('\n', i);
+            const comment = end === -1 ? code.slice(i) : code.slice(i, end);
+            tokens.push({ type: 'comment', text: comment });
+            i += comment.length;
+            continue;
+        }
+        // Strings
+        if (ch === '"' || ch === "'") {
+            let j = i + 1;
+            while (j < code.length && code[j] !== ch) {
+                if (code[j] === '\\')
+                    j++; // skip escaped char
+                j++;
+            }
+            const str = code.slice(i, j + 1);
+            tokens.push({ type: 'string', text: str });
+            i = j + 1;
+            continue;
+        }
+        // Annotations (@export, @onready, etc.)
+        if (ch === '@') {
+            const match = rest.match(/^@\w+/);
+            if (match) {
+                tokens.push({ type: 'annotation', text: match[0] });
+                i += match[0].length;
+                continue;
+            }
+        }
+        // Arrow ->
+        if (rest.startsWith('->')) {
+            tokens.push({ type: 'arrow', text: '->' });
+            i += 2;
+            continue;
+        }
+        // Numbers
+        if (/\d/.test(ch)) {
+            const match = rest.match(/^\d+\.?\d*/);
+            if (match) {
+                tokens.push({ type: 'number', text: match[0] });
+                i += match[0].length;
+                continue;
+            }
+        }
+        // Words (identifiers, keywords, types, function calls)
+        if (/[a-zA-Z_]/.test(ch)) {
+            const match = rest.match(/^[a-zA-Z_]\w*/);
+            if (match) {
+                const word = match[0];
+                const afterWord = code.slice(i + word.length);
+                const isCallable = /^\s*\(/.test(afterWord); // followed by (
+                let type = 'identifier'; // default: white for variables
+                if (GD_KEYWORDS.has(word))
+                    type = 'keyword';
+                else if (GD_TYPES.has(word) || /^[A-Z]/.test(word))
+                    type = 'type';
+                else if (isCallable)
+                    type = 'function'; // function/method calls
+                tokens.push({ type, text: word });
+                i += word.length;
+                continue;
+            }
+        }
+        // Everything else (operators, punctuation, whitespace)
+        tokens.push({ type: 'plain', text: ch });
+        i++;
+    }
+    // Convert tokens to HTML with Godot-like colors
+    return tokens.map(t => {
+        const escaped = t.text.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
+        switch (t.type) {
+            case 'keyword': return `<span style="color:#FF7085">${escaped}</span>`; // Pink/red
+            case 'type': return `<span style="color:#8EFFDA">${escaped}</span>`; // Teal/mint
+            case 'function': return `<span style="color:#66E6FF">${escaped}</span>`; // Cyan (function calls)
+            case 'string': return `<span style="color:#FFE566">${escaped}</span>`; // Yellow
+            case 'number': return `<span style="color:#A3FFB4">${escaped}</span>`; // Green
+            case 'comment': return `<span style="color:#9A9EA6">${escaped}</span>`; // Gray
+            case 'annotation': return `<span style="color:#FFB373">${escaped}</span>`; // Orange
+            case 'arrow': return `<span style="color:#ABC8FF">${escaped}</span>`; // Light blue
+            case 'identifier': return `<span style="color:#CDCFD2">${escaped}</span>`; // White/light gray (variables)
+            default: return escaped;
+        }
+    }).join('');
+}

package/build/visualizer/usages.js

@@ -0,0 +1,352 @@
+/**
+ * Usage detection, delete operations, and floating usage panel
+ */
+import { nodes, selectedNode, pendingDelete, setPendingDelete, currentUsages, setCurrentUsages, esc } from './state.js';
+import { sendCommand } from './websocket.js';
+import { highlightGDScript } from './syntax.js';
+import { openPanel, expandAndHighlightFunction } from './panel.js';
+// ---- Delete with Floating Usage Panel ----
+window.showDeleteUsages = async function (index, isExport, type) {
+    // Get the item name
+    let itemName = '';
+    if (type === 'signal') {
+        const sig = selectedNode.signals[index];
+        itemName = typeof sig === 'string' ? sig : sig.name;
+    }
+    else if (type === 'function') {
+        const func = selectedNode.functions[index];
+        itemName = func?.name || '';
+    }
+    else {
+        const vars = selectedNode.variables.filter(v => v.exported === isExport);
+        itemName = vars[index]?.name || '';
+    }
+    // Store pending delete info and the declaring node
+    setPendingDelete({ index, isExport, type, itemName, declaringNode: selectedNode });
+    // Find usages with smart detection
+    const usages = findUsagesSmart(itemName, type);
+    setCurrentUsages(usages);
+    if (usages.length === 0) {
+        // No usages, delete directly
+        await performDelete(index, isExport, type, itemName);
+        return;
+    }
+    renderUsagePanel();
+};
+function renderUsagePanel() {
+    if (!pendingDelete)
+        return;
+    const { itemName, type } = pendingDelete;
+    const panel = document.getElementById('usage-float-panel');
+    const titleEl = document.getElementById('ufp-title');
+    const countEl = document.getElementById('ufp-count');
+    const listEl = document.getElementById('ufp-list');
+    const deleteBtn = document.getElementById('ufp-delete-btn');
+    // Set title based on type
+    const typeLabel = type === 'signal' ? 'Signal' : type === 'function' ? 'Function' : 'Variable';
+    titleEl.innerHTML = `⚠ Delete ${typeLabel}: <span style="color:#f38ba8;font-weight:600">${itemName}</span>`;
+    if (currentUsages.length === 0) {
+        // All usages fixed! Can delete now
+        countEl.innerHTML = `<span style="color:#a6e3a1">✓ All usages fixed! Safe to delete.</span>`;
+        listEl.innerHTML = '<div style="padding: 30px; text-align: center; color: var(--text-muted);">No more usages found</div>';
+        deleteBtn.textContent = 'Delete Now';
+        deleteBtn.style.background = 'rgba(166, 227, 161, 0.2)';
+        deleteBtn.style.color = '#a6e3a1';
+        deleteBtn.style.borderColor = 'rgba(166, 227, 161, 0.4)';
+    }
+    else {
+        countEl.innerHTML = `Found <span class="count-num">${currentUsages.length}</span> usage${currentUsages.length > 1 ? 's' : ''} — click to navigate`;
+        listEl.innerHTML = currentUsages.map((u, i) => {
+            const highlightedCode = highlightUsageInCode(u.code, itemName);
+            const fileName = u.file.split('/').pop().replace('.gd', '');
+            return `
+        <div class="ufp-item"
+             data-usage-index="${i}"
+             data-file="${u.file}"
+             data-line="${u.line}"
+             data-func="${u.funcName || ''}"
+             onclick="navigateToUsage(this)">
+          <div class="ufp-loc">
+            <span class="ufp-func">${u.funcName || 'unknown'}</span>
+            <span class="ufp-line">line ${u.line}</span>
+          </div>
+          <div class="ufp-code">${highlightedCode}</div>
+          <div class="ufp-file">${fileName}.gd</div>
+        </div>
+      `;
+        }).join('');
+        deleteBtn.textContent = 'Delete Anyway';
+        deleteBtn.style.background = '';
+        deleteBtn.style.color = '';
+        deleteBtn.style.borderColor = '';
+    }
+    deleteBtn.onclick = () => forceDeleteFromPanel();
+    // Position panel if not already positioned by drag
+    if (!panel.dataset.positioned) {
+        const detailPanel = document.getElementById('detail-panel');
+        const detailWidth = detailPanel.offsetWidth;
+        panel.style.right = (detailWidth + 20) + 'px';
+        panel.style.top = '80px';
+        panel.style.left = 'auto';
+    }
+    panel.classList.add('visible');
+    initUsagePanelDrag();
+    initUsagePanelResize();
+}
+window.refreshUsages = function () {
+    if (!pendingDelete)
+        return;
+    const { itemName, type } = pendingDelete;
+    // Re-scan for usages
+    const usages = findUsagesSmart(itemName, type);
+    setCurrentUsages(usages);
+    renderUsagePanel();
+};
+// ---- Draggable Usage Panel ----
+let ufpDragging = false;
+let ufpDragStart = { x: 0, y: 0 };
+let ufpPanelStart = { x: 0, y: 0 };
+function initUsagePanelDrag() {
+    const header = document.getElementById('ufp-header');
+    const panel = document.getElementById('usage-float-panel');
+    // Remove existing listeners
+    header.onmousedown = (e) => {
+        if (e.target.tagName === 'BUTTON')
+            return; // Don't drag when clicking buttons
+        ufpDragging = true;
+        panel.classList.add('dragging');
+        ufpDragStart = { x: e.clientX, y: e.clientY };
+        const rect = panel.getBoundingClientRect();
+        ufpPanelStart = { x: rect.left, y: rect.top };
+        document.addEventListener('mousemove', onUfpDrag);
+        document.addEventListener('mouseup', onUfpDragEnd);
+    };
+}
+function onUfpDrag(e) {
+    if (!ufpDragging)
+        return;
+    const panel = document.getElementById('usage-float-panel');
+    const dx = e.clientX - ufpDragStart.x;
+    const dy = e.clientY - ufpDragStart.y;
+    const newX = ufpPanelStart.x + dx;
+    const newY = ufpPanelStart.y + dy;
+    // Switch to left/top positioning for dragging
+    panel.style.left = Math.max(0, newX) + 'px';
+    panel.style.top = Math.max(0, newY) + 'px';
+    panel.style.right = 'auto';
+    panel.dataset.positioned = 'true';
+}
+function onUfpDragEnd() {
+    ufpDragging = false;
+    document.getElementById('usage-float-panel')?.classList.remove('dragging');
+    document.removeEventListener('mousemove', onUfpDrag);
+    document.removeEventListener('mouseup', onUfpDragEnd);
+}
+// ---- Resizable Usage Panel ----
+let ufpResizing = false;
+let ufpResizeStart = { x: 0, y: 0, w: 0, h: 0 };
+function initUsagePanelResize() {
+    const resizeHandle = document.getElementById('ufp-resize');
+    const panel = document.getElementById('usage-float-panel');
+    resizeHandle.onmousedown = (e) => {
+        e.preventDefault();
+        e.stopPropagation();
+        ufpResizing = true;
+        ufpResizeStart = {
+            x: e.clientX,
+            y: e.clientY,
+            w: panel.offsetWidth,
+            h: panel.offsetHeight
+        };
+        document.addEventListener('mousemove', onUfpResize);
+        document.addEventListener('mouseup', onUfpResizeEnd);
+    };
+}
+function onUfpResize(e) {
+    if (!ufpResizing)
+        return;
+    const panel = document.getElementById('usage-float-panel');
+    const dw = e.clientX - ufpResizeStart.x;
+    const dh = e.clientY - ufpResizeStart.y;
+    const newW = Math.max(300, ufpResizeStart.w + dw);
+    const newH = Math.max(200, ufpResizeStart.h + dh);
+    panel.style.width = newW + 'px';
+    panel.style.height = newH + 'px';
+}
+function onUfpResizeEnd() {
+    ufpResizing = false;
+    document.removeEventListener('mousemove', onUfpResize);
+    document.removeEventListener('mouseup', onUfpResizeEnd);
+}
+function highlightUsageInCode(code, name) {
+    const escaped = esc(code);
+    // Highlight the variable/signal/function name
+    const regex = new RegExp(`\\b(${name})\\b`, 'g');
+    return escaped.replace(regex, '<span class="highlight">$1</span>');
+}
+window.closeUsagePanel = function () {
+    const panel = document.getElementById('usage-float-panel');
+    panel.classList.remove('visible');
+    panel.dataset.positioned = '';
+    panel.style.left = '';
+    panel.style.right = '';
+    panel.style.top = '';
+    setPendingDelete(null);
+    setCurrentUsages([]);
+};
+window.navigateToUsage = function (el) {
+    // Mark this item as active
+    document.querySelectorAll('#ufp-list .ufp-item').forEach(item => {
+        item.classList.remove('active');
+    });
+    el.classList.add('active');
+    const file = el.dataset.file;
+    const line = parseInt(el.dataset.line);
+    const funcName = el.dataset.func;
+    // Find the node for this file
+    const targetNode = nodes.find(n => n.path === file);
+    if (!targetNode) {
+        console.log('Node not found for file:', file);
+        return;
+    }
+    // If it's a different node, switch to it
+    if (selectedNode?.path !== targetNode.path) {
+        openPanel(targetNode);
+        // Wait for panel to render
+        setTimeout(() => {
+            if (funcName) {
+                expandAndHighlightFunction(funcName, line, targetNode);
+            }
+        }, 150);
+    }
+    else {
+        // Same node, just expand/highlight
+        if (funcName) {
+            expandAndHighlightFunction(funcName, line, targetNode);
+        }
+    }
+};
+async function performDelete(index, isExport, type, itemName) {
+    try {
+        if (type === 'signal') {
+            await sendCommand('modify_signal', {
+                path: selectedNode.path,
+                action: 'delete',
+                old_name: itemName
+            });
+            selectedNode.signals.splice(index, 1);
+        }
+        else if (type === 'function') {
+            await sendCommand('modify_function_delete', {
+                path: selectedNode.path,
+                name: itemName
+            });
+            selectedNode.functions.splice(index, 1);
+        }
+        else {
+            await sendCommand('modify_variable', {
+                path: selectedNode.path,
+                action: 'delete',
+                old_name: itemName
+            });
+            const vars = selectedNode.variables.filter(v => v.exported === isExport);
+            const actualIndex = selectedNode.variables.findIndex(v => v.name === vars[index].name);
+            if (actualIndex !== -1)
+                selectedNode.variables.splice(actualIndex, 1);
+        }
+        console.log(`Deleted ${type} "${itemName}" from ${selectedNode.path}`);
+        window.closeUsagePanel();
+        openPanel(selectedNode);
+    }
+    catch (err) {
+        console.error('Failed to delete:', err);
+        alert('Failed to delete: ' + err.message);
+    }
+}
+async function forceDeleteFromPanel() {
+    if (!pendingDelete)
+        return;
+    const { index, isExport, type, itemName } = pendingDelete;
+    await performDelete(index, isExport, type, itemName);
+}
+// ---- Smart Usage Detection ----
+// Avoids false positives like matching "new" in "SomeClass.new()"
+function findUsagesSmart(name, type) {
+    const usages = [];
+    // GDScript built-in methods/keywords to avoid false positives
+    const builtinMethods = ['new', 'free', 'queue_free', 'get', 'set', 'call', 'emit', 'connect', 'disconnect'];
+    const isBuiltinMethod = builtinMethods.includes(name);
+    for (const node of nodes) {
+        // Check if this is the node where the item is declared
+        const isDeclaringNode = node.path === selectedNode?.path;
+        for (const func of (node.functions || [])) {
+            if (!func.body)
+                continue;
+            const lines = func.body.split('\n');
+            lines.forEach((line, i) => {
+                const lineNum = (func.line || 1) + i;
+                // Skip the declaration line itself
+                if (isDeclaringNode && isDeclarationLine(line, name, type)) {
+                    return;
+                }
+                // Check if this line actually uses the variable/signal/function
+                if (isActualUsage(line, name, type, isBuiltinMethod)) {
+                    usages.push({
+                        file: node.path,
+                        line: lineNum,
+                        code: line.trim(),
+                        funcName: func.name
+                    });
+                }
+            });
+        }
+    }
+    return usages;
+}
+function isDeclarationLine(line, name, type) {
+    const trimmed = line.trim();
+    if (type === 'variable') {
+        // var name, @export var name, @onready var name
+        return new RegExp(`^(@export\\s+)?(@onready\\s+)?var\\s+${name}\\b`).test(trimmed);
+    }
+    if (type === 'signal') {
+        return new RegExp(`^signal\\s+${name}\\b`).test(trimmed);
+    }
+    if (type === 'function') {
+        return new RegExp(`^func\\s+${name}\\s*\\(`).test(trimmed);
+    }
+    return false;
+}
+function isActualUsage(line, name, type, isBuiltinMethod) {
+    // Build a regex that matches the name as a word boundary
+    const namePattern = `\\b${name}\\b`;
+    if (!new RegExp(namePattern).test(line)) {
+        return false; // Name not in line at all
+    }
+    // For variables named like builtins (e.g., "new"), do extra checks
+    if (isBuiltinMethod) {
+        // Exclude patterns like "ClassName.new()" or ".new()"
+        // These are constructor calls, not variable usages
+        const constructorPattern = new RegExp(`\\.${name}\\s*\\(`);
+        if (constructorPattern.test(line)) {
+            // Check if the name appears OUTSIDE of a constructor pattern too
+            const withoutConstructors = line.replace(new RegExp(`\\w+\\.${name}\\s*\\([^)]*\\)`, 'g'), '');
+            if (!new RegExp(namePattern).test(withoutConstructors)) {
+                return false; // Only appears in constructor calls
+            }
+        }
+    }
+    // For signals, check for signal-specific patterns
+    if (type === 'signal') {
+        // Match: signal_name.emit(), signal_name.connect(), etc.
+        return new RegExp(`\\b${name}\\s*\\.\\s*(emit|connect|disconnect)\\b`).test(line) ||
+            new RegExp(`\\.${name}\\s*\\.\\s*(connect|emit)`).test(line);
+    }
+    // For functions, match function calls
+    if (type === 'function') {
+        return new RegExp(`\\b${name}\\s*\\(`).test(line);
+    }
+    // For variables, the name should appear as a standalone identifier
+    // Not as part of another word and not only in a method call position
+    return true;
+}