npm - gopeak - Versions diffs - 2.1.0 → 2.2.1 - Mend

gopeak 2.1.0 → 2.2.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (32) hide show

package/README.md +224 -75
package/build/addon/godot_mcp_editor/mcp_client.gd +178 -0
package/build/addon/godot_mcp_editor/plugin.cfg +6 -0
package/build/addon/godot_mcp_editor/plugin.gd +84 -0
package/build/addon/godot_mcp_editor/tool_executor.gd +114 -0
package/build/addon/godot_mcp_editor/tools/animation_tools.gd +502 -0
package/build/addon/godot_mcp_editor/tools/resource_tools.gd +425 -0
package/build/addon/godot_mcp_editor/tools/scene_tools.gd +710 -0
package/build/cli/check.js +77 -0
package/build/cli/notify.js +88 -0
package/build/cli/setup.js +115 -0
package/build/cli/star.js +51 -0
package/build/cli/uninstall.js +26 -0
package/build/cli/utils.js +149 -0
package/build/cli.js +91 -0
package/build/gdscript_parser.js +828 -0
package/build/godot-bridge.js +556 -0
package/build/index.js +2761 -2064
package/build/prompts.js +163 -0
package/build/visualizer/canvas.js +832 -0
package/build/visualizer/events.js +814 -0
package/build/visualizer/layout.js +304 -0
package/build/visualizer/main.js +245 -0
package/build/visualizer/modals.js +239 -0
package/build/visualizer/panel.js +1091 -0
package/build/visualizer/state.js +210 -0
package/build/visualizer/syntax.js +106 -0
package/build/visualizer/usages.js +352 -0
package/build/visualizer/websocket.js +85 -0
package/build/visualizer-server.js +375 -0
package/build/visualizer.html +6395 -0
package/package.json +15 -6

package/build/visualizer/websocket.js ADDED Viewed

@@ -0,0 +1,85 @@
+/**
+ * WebSocket connection for real-time communication with Godot
+ */
+let ws = null;
+let wsConnected = false;
+const pendingRequests = new Map();
+let requestId = 0;
+const actionListeners = [];
+export function onActionEvent(callback) {
+    actionListeners.push(callback);
+}
+function handleActionEvent(msg) {
+    for (const listener of actionListeners) {
+        try {
+            listener(msg);
+        }
+        catch (err) {
+            console.error('[visualizer] Action listener error:', err);
+        }
+    }
+}
+export function connectWebSocket() {
+    const protocol = window.location.protocol === 'https:' ? 'wss:' : 'ws:';
+    ws = new WebSocket(`${protocol}//${window.location.host}/visualizer`);
+    ws.onopen = () => {
+        wsConnected = true;
+        console.log('[visualizer] WebSocket connected');
+    };
+    ws.onclose = () => {
+        wsConnected = false;
+        console.log('[visualizer] WebSocket disconnected, reconnecting...');
+        setTimeout(connectWebSocket, 2000);
+    };
+    ws.onerror = (err) => {
+        console.error('[visualizer] WebSocket error:', err);
+    };
+    ws.onmessage = (event) => {
+        try {
+            const msg = JSON.parse(event.data);
+            if (msg.type === 'action_event' && !msg.id) {
+                handleActionEvent(msg);
+                return;
+            }
+            if (msg.id && pendingRequests.has(msg.id)) {
+                const { resolve, reject } = pendingRequests.get(msg.id);
+                pendingRequests.delete(msg.id);
+                if (msg.error) {
+                    reject(new Error(msg.error));
+                }
+                else {
+                    resolve(msg.result || msg);
+                }
+            }
+        }
+        catch (err) {
+            console.error('[visualizer] Failed to parse message:', err);
+        }
+    };
+}
+export function sendCommand(command, args) {
+    return new Promise((resolve, reject) => {
+        if (!wsConnected || !ws) {
+            reject(new Error('WebSocket not connected'));
+            return;
+        }
+        const id = ++requestId;
+        pendingRequests.set(id, { resolve, reject });
+        ws.send(JSON.stringify({
+            type: 'visualizer_command',
+            id,
+            command,
+            args
+        }));
+        // Timeout after 30 seconds
+        setTimeout(() => {
+            if (pendingRequests.has(id)) {
+                pendingRequests.delete(id);
+                reject(new Error('Request timeout'));
+            }
+        }, 30000);
+    });
+}
+export function isConnected() {
+    return wsConnected;
+}

package/build/visualizer-server.js ADDED Viewed

@@ -0,0 +1,375 @@
+import { exec, execSync } from 'node:child_process';
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { WebSocket } from 'ws';
+import { createScriptFile, deleteFunction, findUsages, modifyFunction, modifySignal, modifyVariable, refreshMap, resolvePath, } from './gdscript_parser.js';
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+let wss = null;
+let currentProjectPath = null;
+let currentBridge = null;
+const DEFAULT_VISUALIZER_HTML = `<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <title>Godot MCP Visualizer</title>
+  </head>
+  <body>
+    <h1>Godot MCP Visualizer</h1>
+    <p>Run the map_project tool to load visualization data.</p>
+  </body>
+</html>`;
+const handleVisualizerConnectionRef = (socket) => {
+    handleVisualizerConnection(socket);
+};
+const onToolStart = (event) => {
+    broadcastToVisualizer({
+        type: 'tool_event',
+        event: 'start',
+        ...event,
+    });
+};
+const onToolEnd = (event) => {
+    broadcastToVisualizer({
+        type: 'tool_event',
+        event: 'end',
+        ...event,
+    });
+};
+const onGodotConnected = (event) => {
+    broadcastToVisualizer({
+        type: 'connection_event',
+        event: 'godot_connected',
+        ...event,
+    });
+};
+const onGodotDisconnected = () => {
+    broadcastToVisualizer({
+        type: 'connection_event',
+        event: 'godot_disconnected',
+    });
+};
+export function setProjectPath(projectPath) {
+    currentProjectPath = projectPath;
+    const snapshot = readGitSnapshot(projectPath);
+    if (snapshot) {
+        lastGitSnapshotByProject.set(projectPath, snapshot);
+    }
+    else {
+        lastGitSnapshotByProject.delete(projectPath);
+    }
+}
+export async function serveVisualization(projectData, bridge) {
+    if (wss) {
+        wss.off('connection', handleVisualizerConnectionRef);
+    }
+    detachBridgeHandlers();
+    const htmlPath = path.join(__dirname, 'visualizer.html');
+    let html;
+    try {
+        html = fs.readFileSync(htmlPath, 'utf-8');
+    }
+    catch {
+        throw new Error(`Visualizer HTML template not found at ${htmlPath}`);
+    }
+    const dataJson = JSON.stringify(projectData);
+    html = html.replace('"%%PROJECT_DATA%%"', dataJson);
+    bridge.setVisualizerHtml(html);
+    currentBridge = bridge;
+    wss = bridge.getVisualizerWss();
+    if (!wss) {
+        throw new Error('Visualizer WebSocket server is not initialized. Start Godot bridge first.');
+    }
+    wss.off('connection', handleVisualizerConnectionRef);
+    wss.on('connection', handleVisualizerConnectionRef);
+    bridge.on('tool_start', onToolStart);
+    bridge.on('tool_end', onToolEnd);
+    bridge.on('godot_connected', onGodotConnected);
+    bridge.on('godot_disconnected', onGodotDisconnected);
+    const url = `http://localhost:${bridge.getStatus().port}`;
+    console.error(`[visualizer] Serving at ${url}`);
+    openBrowser(url);
+    return url;
+}
+function handleVisualizerConnection(ws) {
+    console.error('[visualizer] Browser connected via WebSocket');
+    if (currentBridge) {
+        ws.send(JSON.stringify({
+            type: 'godot_status',
+            status: currentBridge.getStatus(),
+        }));
+    }
+    ws.on('message', async (data) => {
+        try {
+            const message = JSON.parse(data.toString());
+            const result = await handleInternalCommand(message);
+            ws.send(JSON.stringify({ id: message.id, ...result }));
+        }
+        catch (error) {
+            const errMsg = error instanceof Error ? error.message : 'Unknown error';
+            ws.send(JSON.stringify({ error: errMsg }));
+        }
+    });
+    ws.on('close', () => {
+        console.error('[visualizer] Browser disconnected');
+    });
+}
+function parseDiffHunks(diffText) {
+    const hunks = [];
+    let additions = 0;
+    let deletions = 0;
+    const hunkRegex = /^@@\s+-\d+(?:,\d+)?\s+\+(\d+)(?:,(\d+))?\s+@@(.*)$/;
+    const diffLines = diffText.split('\n');
+    let currentHunk = null;
+    for (const line of diffLines) {
+        const match = line.match(hunkRegex);
+        if (match) {
+            if (currentHunk) {
+                hunks.push(currentHunk);
+            }
+            const start = parseInt(match[1], 10);
+            const count = match[2] ? parseInt(match[2], 10) : 1;
+            currentHunk = { startLine: start, endLine: start + count - 1, header: match[3].trim(), lines: [] };
+        }
+        else if (currentHunk) {
+            currentHunk.lines.push(line);
+            if (line.startsWith('+') && !line.startsWith('+++')) {
+                additions++;
+            }
+            if (line.startsWith('-') && !line.startsWith('---')) {
+                deletions++;
+            }
+        }
+    }
+    if (currentHunk) {
+        hunks.push(currentHunk);
+    }
+    return { hunks, additions, deletions };
+}
+function runDiffCommand(command, cwd) {
+    try {
+        return execSync(command, { cwd, encoding: 'utf-8', timeout: 5000 });
+    }
+    catch (error) {
+        const stdout = error.stdout;
+        if (typeof stdout === 'string') {
+            return stdout;
+        }
+        if (Buffer.isBuffer(stdout)) {
+            return stdout.toString('utf-8');
+        }
+        throw error;
+    }
+}
+function quoteForShell(value) {
+    return `"${value.replace(/[\\"$`]/g, '\\$&')}"`;
+}
+const actionLog = [];
+const MAX_ACTION_LOG = 100;
+const lastGitSnapshotByProject = new Map();
+function appendActionEntry(entry) {
+    actionLog.push(entry);
+    if (actionLog.length > MAX_ACTION_LOG) {
+        actionLog.shift();
+    }
+    if (!wss) {
+        return;
+    }
+    const msg = JSON.stringify({ type: 'action_event', entry });
+    wss.clients.forEach((c) => {
+        if (c.readyState === WebSocket.OPEN) {
+            c.send(msg);
+        }
+    });
+}
+function parseGitStatusLine(xy) {
+    if (xy === '??') {
+        return 'untracked';
+    }
+    if (xy.includes('A')) {
+        return 'added';
+    }
+    return 'modified';
+}
+function readGitSnapshot(projectPath) {
+    const gitDir = path.join(projectPath, '.git');
+    if (!fs.existsSync(gitDir)) {
+        return null;
+    }
+    try {
+        const raw = runDiffCommand('git status --porcelain', projectPath);
+        const snapshot = new Map();
+        for (const line of raw.split('\n')) {
+            if (!line.trim()) {
+                continue;
+            }
+            const xy = line.substring(0, 2);
+            const filePath = line.substring(3).trim();
+            const actualPath = filePath.includes(' -> ') ? filePath.split(' -> ')[1] : filePath;
+            const resFilePath = 'res://' + actualPath;
+            snapshot.set(resFilePath, parseGitStatusLine(xy));
+        }
+        return snapshot;
+    }
+    catch {
+        return null;
+    }
+}
+function recordExternalChanges(projectPath) {
+    const previous = lastGitSnapshotByProject.get(projectPath);
+    const current = readGitSnapshot(projectPath);
+    if (!current) {
+        lastGitSnapshotByProject.delete(projectPath);
+        return;
+    }
+    if (!previous) {
+        lastGitSnapshotByProject.set(projectPath, current);
+        return;
+    }
+    for (const [filePath, status] of current) {
+        const prevStatus = previous.get(filePath);
+        if (prevStatus === status) {
+            continue;
+        }
+        appendActionEntry({
+            ts: new Date().toISOString(),
+            command: 'external_change_detected',
+            filePath,
+            details: {
+                path: filePath,
+                status,
+            },
+            reason: 'Detected during refresh',
+        });
+    }
+    lastGitSnapshotByProject.set(projectPath, current);
+}
+const MUTATION_COMMANDS = new Set([
+    'create_script_file',
+    'modify_variable',
+    'modify_signal',
+    'modify_function',
+    'modify_function_delete',
+]);
+const COMMAND_MAP = {
+    refresh_map: (pp, args) => {
+        const result = refreshMap(pp, args);
+        if (result.ok) {
+            recordExternalChanges(pp);
+        }
+        return result;
+    },
+    create_script_file: (pp, args) => createScriptFile(pp, args),
+    modify_variable: (pp, args) => modifyVariable(pp, args),
+    modify_signal: (pp, args) => modifySignal(pp, args),
+    modify_function: (pp, args) => modifyFunction(pp, args),
+    modify_function_delete: (pp, args) => deleteFunction(pp, args),
+    find_usages: (pp, args) => findUsages(pp, args),
+    get_action_log: (_pp, _args) => ({ ok: true, entries: actionLog }),
+    get_file_diff: (pp, args) => {
+        try {
+            const requestPath = args.path || '';
+            if (!requestPath) {
+                return { ok: false, error: 'Missing required argument: path' };
+            }
+            const absolutePath = resolvePath(pp, requestPath);
+            const quotedAbsolutePath = quoteForShell(absolutePath);
+            let diffText = runDiffCommand(`git diff HEAD -- ${quotedAbsolutePath}`, pp);
+            if (diffText.trim() === '' && fs.existsSync(absolutePath)) {
+                const relPath = path.relative(pp, absolutePath);
+                const quotedRelPath = quoteForShell(relPath);
+                const untracked = runDiffCommand(`git ls-files --others --exclude-standard -- ${quotedRelPath}`, pp);
+                if (untracked.trim() !== '') {
+                    diffText = runDiffCommand(`git diff --no-index /dev/null ${quotedAbsolutePath}`, pp);
+                }
+            }
+            const parsed = parseDiffHunks(diffText);
+            return {
+                ok: true,
+                diff: {
+                    path: requestPath,
+                    hunks: parsed.hunks,
+                    summary: {
+                        additions: parsed.additions,
+                        deletions: parsed.deletions,
+                    },
+                },
+            };
+        }
+        catch (error) {
+            const errMsg = error instanceof Error ? error.message : 'Unknown error';
+            return { ok: false, error: errMsg };
+        }
+    },
+};
+async function handleInternalCommand(message) {
+    const { command, args } = message;
+    if (!currentProjectPath) {
+        return { ok: false, error: 'No project path set. Call map_project first.' };
+    }
+    console.error(`[visualizer] Internal command: ${command}`);
+    const handler = COMMAND_MAP[command];
+    if (handler) {
+        try {
+            const result = handler(currentProjectPath, args);
+            if (result.ok && MUTATION_COMMANDS.has(command)) {
+                appendActionEntry({
+                    ts: new Date().toISOString(),
+                    command,
+                    filePath: args.path || '',
+                    details: { ...args },
+                    reason: args.reason || undefined,
+                });
+            }
+            return result;
+        }
+        catch (error) {
+            const errMsg = error instanceof Error ? error.message : 'Unknown error';
+            return { ok: false, error: errMsg };
+        }
+    }
+    return { ok: false, error: `Unknown command: ${command}` };
+}
+export function stopVisualizationServer() {
+    if (wss) {
+        wss.off('connection', handleVisualizerConnectionRef);
+        wss = null;
+    }
+    if (currentBridge) {
+        currentBridge.setVisualizerHtml(DEFAULT_VISUALIZER_HTML);
+        detachBridgeHandlers();
+        currentBridge = null;
+        console.error('[visualizer] Server detached from unified bridge');
+    }
+}
+function detachBridgeHandlers() {
+    if (!currentBridge) {
+        return;
+    }
+    currentBridge.off('tool_start', onToolStart);
+    currentBridge.off('tool_end', onToolEnd);
+    currentBridge.off('godot_connected', onGodotConnected);
+    currentBridge.off('godot_disconnected', onGodotDisconnected);
+}
+function broadcastToVisualizer(message) {
+    if (!wss) {
+        return;
+    }
+    const payload = JSON.stringify(message);
+    wss.clients.forEach((client) => {
+        if (client.readyState === WebSocket.OPEN) {
+            client.send(payload);
+        }
+    });
+}
+function openBrowser(url) {
+    const cmd = process.platform === 'darwin' ? 'open'
+        : process.platform === 'win32' ? 'start'
+            : 'xdg-open';
+    exec(`${cmd} ${url}`, (err) => {
+        if (err) {
+            console.error(`[visualizer] Could not open browser: ${err.message}`);
+        }
+    });
+}