@beremaran/godot-agent-loop 1.0.0

package/build/tool-mutation-policy.js

@@ -0,0 +1,122 @@
+import { toolManifest } from './tool-manifest.js';
+/**
+ * Calls which only observe state. Everything not listed here is deliberately
+ * classified as mutating so a newly added tool cannot bypass the editor's
+ * cooperative driver lock by omission.
+ */
+export const READ_ONLY_TOOLS = new Set([
+    'get_debug_output',
+    'get_godot_version',
+    'list_projects',
+    'get_project_info',
+    'get_uid',
+    'game_screenshot',
+    'game_get_ui',
+    'game_get_scene_tree',
+    'game_get_property',
+    'game_get_node_info',
+    'game_get_nodes_in_group',
+    'game_find_nodes_by_class',
+    'read_scene',
+    'read_project_settings',
+    'list_project_files',
+    'read_file',
+    'game_get_errors',
+    'game_get_logs',
+    'game_get_camera',
+    'game_raycast',
+    'game_get_audio',
+    'game_list_signals',
+    'game_os_info',
+    'game_physics_3d',
+    'game_physics_2d',
+    'validate_script',
+    'validate_scripts',
+]);
+/** Read-only modes on tools whose other actions mutate project/runtime state. */
+export const READ_ONLY_ACTIONS = {
+    godot_tools: ['search', 'describe'],
+    editor_control: ['inspect'],
+    run_project_tests: ['discover'],
+    manage_import_pipeline: ['inspect', 'dependencies'],
+    analyze_project_integrity: ['analyze', 'preview_rename', 'assets', 'localization', 'accessibility', 'extensions', 'leaks'],
+    verify_export_readiness: ['inspect'],
+    verify_dotnet_project: ['inspect'],
+    manage_addon: ['inspect'],
+    game_performance: ['sample', 'report', 'leaks'],
+    game_play_animation: ['get_list'],
+    manage_autoloads: ['list'],
+    manage_input_map: ['list'],
+    manage_export_presets: ['list'],
+    game_tilemap: ['get_cell', 'get_used_cells'],
+    game_environment: ['get'],
+    game_manage_group: ['get_groups'],
+    game_bone_pose: ['list', 'get'],
+    game_viewport: ['get'],
+    game_websocket: ['status'],
+    game_multiplayer: ['status'],
+    game_input_state: ['query'],
+    game_input_action: ['list'],
+    game_script: ['get_source'],
+    game_window: ['get'],
+    game_time_scale: ['get'],
+    game_world_settings: ['get'],
+    game_multimesh: ['get_info'],
+    game_gridmap: ['get_cell', 'get_used'],
+    game_path_3d: ['get_points'],
+    game_camera_attributes: ['get'],
+    game_path_2d: ['get_points'],
+    game_shape_2d: ['get_points'],
+    game_animation_tree: ['get_state'],
+    game_animation_control: ['get_info'],
+    game_audio_effect: ['list'],
+    game_audio_bus_layout: ['list'],
+    game_audio_spatial: ['get_info'],
+    manage_resource: ['read'],
+    manage_scene_signals: ['list'],
+    manage_layers: ['list'],
+    manage_plugins: ['list'],
+    manage_shader: ['read'],
+    manage_theme_resource: ['read'],
+    manage_translations: ['list'],
+    game_locale: ['get', 'translate'],
+    game_ui_control: ['get_info'],
+    game_ui_text: ['get'],
+    game_ui_popup: ['get_info'],
+    game_ui_tree: ['get_items'],
+    game_ui_item_list: ['get_items'],
+    game_ui_tabs: ['get_tabs'],
+    game_ui_menu: ['get_items'],
+    game_ui_range: ['get'],
+    game_render_settings: ['get'],
+    game_resource: ['exists'],
+    game_visual_shader: ['get_nodes'],
+    game_terrain: ['get_height'],
+    game_video: ['get_status'],
+    manage_ci_pipeline: ['read'],
+    manage_docker_export: ['read'],
+};
+/**
+ * Returns true unless a call is explicitly proven observational. Unknown tools,
+ * missing selectors, and action fields used as data all remain mutating.
+ */
+export function isToolCallMutating(name, args) {
+    if (name === 'godot_tools' && args.action === 'call') {
+        if (typeof args.toolName !== 'string' || args.toolName === 'godot_tools')
+            return true;
+        const nested = args.arguments && typeof args.arguments === 'object' && !Array.isArray(args.arguments)
+            ? args.arguments
+            : {};
+        return isToolCallMutating(args.toolName, nested);
+    }
+    if (!Object.prototype.hasOwnProperty.call(toolManifest, name))
+        return true;
+    const toolName = name;
+    if (READ_ONLY_TOOLS.has(toolName))
+        return false;
+    const entry = toolManifest[toolName];
+    if (entry.actionParamIsData)
+        return true;
+    const readOnlyActions = READ_ONLY_ACTIONS[toolName];
+    return !readOnlyActions?.includes(typeof args.action === 'string' ? args.action : '');
+}

package/build/tool-registry.js

@@ -0,0 +1,34 @@
+import { ErrorCode, McpError } from '@modelcontextprotocol/sdk/types.js';
+import { toolDefinitions } from './tool-definitions.js';
+import { createToolArgumentParser, ToolArgumentValidationError } from './tool-argument-validation.js';
+/**
+ * Dispatches MCP tool calls to their handlers.
+ */
+export class ToolRegistry {
+    preflight;
+    handlers = new Map();
+    parseArguments = createToolArgumentParser(toolDefinitions);
+    constructor(handlers, preflight) {
+        this.preflight = preflight;
+        this.handlers = new Map(Object.entries(handlers));
+    }
+    dispatch(name, args) {
+        const handler = this.handlers.get(name);
+        if (!handler) {
+            throw new McpError(ErrorCode.MethodNotFound, `Unknown tool: ${name}`);
+        }
+        try {
+            const parsed = this.parseArguments(name, args);
+            if (!this.preflight)
+                return handler(parsed);
+            return Promise.resolve(this.preflight(name, parsed))
+                .then(blocked => blocked ?? handler(parsed));
+        }
+        catch (error) {
+            if (error instanceof ToolArgumentValidationError) {
+                throw new McpError(ErrorCode.InvalidParams, error.message);
+            }
+            throw error;
+        }
+    }
+}

package/build/tool-surface.js

@@ -0,0 +1,70 @@
+import { toolDefinitions } from './tool-definitions.js';
+import { toolManifest } from './tool-manifest.js';
+export const TOOL_SURFACE_ENV = 'GODOT_MCP_TOOL_SURFACE';
+/**
+ * Stable, task-oriented starting surface. The complete catalog remains callable
+ * through godot_tools and can be advertised directly with TOOL_SURFACE_ENV=full.
+ */
+export const CORE_TOOL_NAMES = new Set([
+    'godot_tools',
+    'launch_editor', 'editor_control', 'run_project', 'verify_project', 'run_project_tests',
+    'get_debug_output', 'stop_project', 'get_godot_version', 'list_projects', 'get_project_info',
+    'create_project', 'create_scene', 'add_node', 'read_scene', 'modify_scene_node',
+    'remove_scene_node', 'save_scene', 'create_script', 'attach_script', 'read_file',
+    'write_file', 'validate_script', 'validate_scripts', 'read_project_settings',
+    'modify_project_settings', 'list_project_files', 'manage_input_map', 'set_main_scene',
+    'game_get_scene_tree', 'game_get_ui', 'game_screenshot', 'game_get_node_info',
+    'game_get_errors', 'game_get_logs', 'game_wait', 'game_click', 'game_key_press',
+    'game_key_release',
+]);
+export const TOOL_SURFACE_BUDGETS = {
+    fullBytesMax: 100_000,
+    coreBytesMax: 25_000,
+    coreEstimatedTokensMax: 6_250,
+    coreToolCountMax: 40,
+    coreReductionPercentMin: 70,
+};
+export function resolveToolSurfaceMode(value = process.env[TOOL_SURFACE_ENV]) {
+    return value === 'full' ? 'full' : 'core';
+}
+export function advertisedToolDefinitions(mode = resolveToolSurfaceMode()) {
+    return mode === 'full'
+        ? toolDefinitions
+        : toolDefinitions.filter(definition => CORE_TOOL_NAMES.has(definition.name));
+}
+export function compactToolSurfaceBytes(definitions) {
+    return Buffer.byteLength(JSON.stringify(definitions), 'utf8');
+}
+export function estimatedToolSurfaceTokens(definitions) {
+    return Math.ceil(compactToolSurfaceBytes(definitions) / 4);
+}
+export function searchToolCatalog(query, domain, limit = 20) {
+    const terms = query.toLowerCase().trim().split(/\s+/).filter(Boolean);
+    return toolDefinitions
+        .filter(definition => {
+        const manifest = toolManifest[definition.name];
+        if (domain && manifest.domain !== domain)
+            return false;
+        const searchable = [definition.name, definition.description, ...(manifest.actions ?? [])]
+            .join(' ').toLowerCase();
+        return terms.every(term => searchable.includes(term));
+    })
+        .slice(0, limit)
+        .map(definition => {
+        const manifest = toolManifest[definition.name];
+        return {
+            name: definition.name,
+            domain: manifest.domain,
+            description: definition.description,
+            actions: manifest.actions ?? ['*'],
+            privileged: manifest.privileged,
+        };
+    });
+}
+export function describeCatalogTool(name) {
+    const definition = toolDefinitions.find(candidate => candidate.name === name);
+    if (!definition)
+        return undefined;
+    const manifest = toolManifest[definition.name];
+    return { definition, domain: manifest.domain, backend: manifest.backend, privileged: manifest.privileged };
+}

package/build/utils.js

@@ -0,0 +1,273 @@
+import * as fs from 'fs';
+import { isAbsolute, relative, resolve } from 'path';
+export function errorMessage(error) {
+    return error instanceof Error ? error.message : 'Unknown error';
+}
+export const PARAMETER_MAPPINGS = {
+    'msaa_2d': 'msaa2d',
+    'msaa_3d': 'msaa3d',
+    // Runtime mouse handlers historically consume these wire names directly.
+    'relative_x': 'relative_x',
+    'relative_y': 'relative_y',
+};
+const OPAQUE_PARAMETER_OBJECTS = new Set(['properties', 'shapeParams', 'overrides', 'headers', 'args']);
+export const REVERSE_PARAMETER_MAPPINGS = Object.fromEntries(Object.entries(PARAMETER_MAPPINGS).map(([snake, camel]) => [camel, snake]));
+export function normalizeParameters(params) {
+    if (!params || typeof params !== 'object') {
+        return params;
+    }
+    const result = {};
+    for (const key in params) {
+        if (Object.prototype.hasOwnProperty.call(params, key)) {
+            const normalizedKey = PARAMETER_MAPPINGS[key] || key.replace(/_([a-z0-9])/g, (_, letter) => letter.toUpperCase());
+            const value = params[key];
+            result[normalizedKey] = OPAQUE_PARAMETER_OBJECTS.has(normalizedKey) ? value : normalizeValue(value);
+        }
+    }
+    return result;
+}
+/**
+ * Normalize a value of any shape. Arrays must stay arrays at every depth: a
+ * nested array is still `typeof "object"`, so treating it as a record turned
+ * mesh buffers like `[[x, y, z], ...]` into `[{"0": x, "1": y, "2": z}, ...]`
+ * and the engine read them as empty.
+ */
+function normalizeValue(value) {
+    if (Array.isArray(value))
+        return value.map(normalizeValue);
+    if (value && typeof value === 'object')
+        return normalizeParameters(value);
+    return value;
+}
+export function convertCamelToSnakeCase(params) {
+    const result = {};
+    for (const key in params) {
+        if (Object.prototype.hasOwnProperty.call(params, key)) {
+            const snakeKey = REVERSE_PARAMETER_MAPPINGS[key] || key.replace(/[A-Z]/g, letter => `_${letter.toLowerCase()}`);
+            const value = params[key];
+            result[snakeKey] = OPAQUE_PARAMETER_OBJECTS.has(key) || OPAQUE_PARAMETER_OBJECTS.has(snakeKey)
+                ? value
+                : snakeCaseValue(value);
+        }
+    }
+    return result;
+}
+/** Mirrors normalizeValue: nested arrays stay arrays, so mesh buffers survive. */
+function snakeCaseValue(value) {
+    if (Array.isArray(value))
+        return value.map(snakeCaseValue);
+    if (value && typeof value === 'object')
+        return convertCamelToSnakeCase(value);
+    return value;
+}
+export function validatePath(path) {
+    if (!path || path.includes('..')) {
+        return false;
+    }
+    return true;
+}
+/** Centralized filesystem policy for project and project-relative paths. */
+export class PathSecurity {
+    allowedRoots;
+    supportsRealpath = Object.keys(fs).includes('realpathSync');
+    constructor(allowedRoots) {
+        const configured = allowedRoots ?? (process.env.GODOT_MCP_ALLOWED_DIRS || '')
+            .split(process.platform === 'win32' ? /[;,]/ : /[:,]/)
+            .map(value => value.trim())
+            .filter(Boolean);
+        this.allowedRoots = configured.map(root => this.realpathWithFallback(root));
+    }
+    isProjectPathAllowed(projectPath, allowMissing = false) {
+        if (!validatePath(projectPath))
+            return false;
+        if (this.allowedRoots.length === 0)
+            return true;
+        if (!allowMissing && !fs.existsSync(projectPath))
+            return false;
+        if (this.allowedRoots.some(root => resolve(projectPath) === root))
+            return true;
+        return this.isWithinAllowedRoots(this.realpathWithFallback(projectPath));
+    }
+    resolveProjectPath(projectPath, relativePath) {
+        const projectRelativePath = relativePath.startsWith('res://') ? relativePath.slice('res://'.length) : relativePath;
+        if (!this.hasRealpath() && this.allowedRoots.some(root => resolve(projectPath) === root) && validatePath(projectRelativePath)) {
+            return resolve(projectPath, projectRelativePath);
+        }
+        if (!this.supportsRealpath && validatePath(projectPath) && validateRelativePath(relativePath)) {
+            return resolve(projectPath, projectRelativePath);
+        }
+        if (!this.isProjectPathAllowed(projectPath) || !validateRelativePath(relativePath))
+            return null;
+        const projectRoot = this.realpathWithFallback(projectPath);
+        const candidate = resolve(projectRoot, projectRelativePath);
+        return this.isWithin(candidate, projectRoot) && this.isWithin(this.realpathWithFallback(candidate), projectRoot)
+            ? candidate
+            : null;
+    }
+    isRelativePathAllowed(projectPath, relativePath) {
+        return this.resolveProjectPath(projectPath, relativePath) !== null;
+    }
+    isWithinAllowedRoots(target) {
+        return this.allowedRoots.length === 0 || this.allowedRoots.some(root => this.isWithin(target, root));
+    }
+    isWithin(target, root) {
+        const rel = relative(root, target);
+        return rel === '' || (!rel.startsWith('..') && !isAbsolute(rel));
+    }
+    realpathWithFallback(target) {
+        const absolute = resolve(target);
+        if (fs.existsSync(absolute)) {
+            const mockedRealpath = (Object.keys(fs).includes('realpathSync'))
+                ? fs.realpathSync
+                : undefined;
+            const realpath = mockedRealpath?.native ?? mockedRealpath;
+            return realpath ? realpath(absolute) : absolute;
+        }
+        const parent = resolve(absolute, '..');
+        return parent === absolute ? absolute : resolve(this.realpathWithFallback(parent), absolute.slice(parent.length + 1));
+    }
+    hasRealpath() {
+        try {
+            return typeof fs.realpathSync === 'function';
+        }
+        catch {
+            return false;
+        }
+    }
+}
+function validateRelativePath(path) {
+    return Boolean(path) && !isAbsolute(path) && validatePath(path);
+}
+export function createErrorResponse(message) {
+    console.error(`[SERVER] Error response: ${message}`);
+    return {
+        content: [
+            {
+                type: 'text',
+                text: message,
+            },
+        ],
+        isError: true,
+    };
+}
+export function isGodot44OrLater(version) {
+    const match = /^(\d+)\.(\d+)/.exec(version);
+    if (match) {
+        const major = parseInt(match[1], 10);
+        const minor = parseInt(match[2], 10);
+        return major > 4 || (major === 4 && minor >= 4);
+    }
+    return false;
+}
+export function parseGodotScriptDiagnostics(output) {
+    const lines = (output || '').split(/\r?\n/);
+    const diagnostics = [];
+    const locRe = /\((res:\/\/.+):(\d+)\)/;
+    for (let i = 0; i < lines.length; i++) {
+        const m = /SCRIPT ERROR:\s*(.+?)\s*$/.exec(lines[i]);
+        if (!m)
+            continue;
+        const message = m[1].replace(/^Parse Error:\s*/, '');
+        let file;
+        let line;
+        for (const j of [i + 1, i]) {
+            if (j >= lines.length)
+                continue;
+            const loc = locRe.exec(lines[j]);
+            if (loc) {
+                file = loc[1];
+                line = parseInt(loc[2], 10);
+                break;
+            }
+        }
+        diagnostics.push({ message, ...(file ? { file } : {}), ...(line !== undefined ? { line } : {}) });
+    }
+    return diagnostics;
+}
+export function collectGdPaths(outputs) {
+    const result = [];
+    const seen = new Set();
+    for (const out of outputs) {
+        for (const rawLine of (out || '').split(/\r?\n/)) {
+            const filePath = rawLine.trim().replace(/\\/g, '/');
+            if (!/\.gd$/i.test(filePath))
+                continue;
+            if (!seen.has(filePath)) {
+                seen.add(filePath);
+                result.push(filePath);
+            }
+        }
+    }
+    return result;
+}
+export const DEFAULT_GODOT_NET_SDK_VERSION = '4.4.0';
+export const DEFAULT_DOTNET_TARGET_FRAMEWORK = 'net8.0';
+export function toDotnetIdentifier(name) {
+    const cleaned = (name || '').replace(/[^A-Za-z0-9_]/g, '_');
+    if (cleaned.length === 0)
+        return 'Game';
+    return /^[0-9]/.test(cleaned) ? '_' + cleaned : cleaned;
+}
+export function toDotnetNamespace(name) {
+    return (name || '')
+        .split('.')
+        .map(seg => toDotnetIdentifier(seg))
+        .join('.');
+}
+export function isValidCsharpIdentifier(name) {
+    return /^[A-Za-z_][A-Za-z0-9_]*$/.test(name);
+}
+export function generateGodotProjectFeatures(isDotnet, version = '4.4') {
+    return isDotnet
+        ? `PackedStringArray("${version}", "C#")`
+        : `PackedStringArray("${version}")`;
+}
+export function generateCsprojContent(projectName, sdkVersion = DEFAULT_GODOT_NET_SDK_VERSION, targetFramework = DEFAULT_DOTNET_TARGET_FRAMEWORK) {
+    const rootNamespace = toDotnetIdentifier(projectName);
+    return `<Project Sdk="Godot.NET.Sdk/${sdkVersion}">
+  <PropertyGroup>
+    <TargetFramework>${targetFramework}</TargetFramework>
+    <EnableDynamicLoading>true</EnableDynamicLoading>
+    <Nullable>enable</Nullable>
+    <RootNamespace>${rootNamespace}</RootNamespace>
+  </PropertyGroup>
+</Project>
+`;
+}
+const CSHARP_GODOT_OVERRIDES = {
+    _Ready: 'public override void _Ready()',
+    _Process: 'public override void _Process(double delta)',
+    _PhysicsProcess: 'public override void _PhysicsProcess(double delta)',
+    _Input: 'public override void _Input(InputEvent @event)',
+    _UnhandledInput: 'public override void _UnhandledInput(InputEvent @event)',
+    _EnterTree: 'public override void _EnterTree()',
+    _ExitTree: 'public override void _ExitTree()',
+};
+export function generateCsharpScriptSource(opts) {
+    const className = toDotnetIdentifier(opts.className);
+    const baseClass = (opts.baseClass?.trim()) || 'Node';
+    const indent = opts.namespaceName ? '\t\t' : '\t';
+    const bodyIndent = indent + '\t';
+    const methodBlocks = [];
+    const seenMethods = new Set();
+    for (const raw of opts.methods || []) {
+        const name = String(raw).trim();
+        if (!name || seenMethods.has(name))
+            continue;
+        seenMethods.add(name);
+        const signature = CSHARP_GODOT_OVERRIDES[name] || `public void ${toDotnetIdentifier(name)}()`;
+        methodBlocks.push(`${indent}${signature}\n${indent}{\n${bodyIndent}\n${indent}}`);
+    }
+    const body = methodBlocks.length > 0 ? methodBlocks.join('\n\n') : indent;
+    const classIndent = opts.namespaceName ? '\t' : '';
+    const classBlock = `${classIndent}public partial class ${className} : ${baseClass}\n` +
+        `${classIndent}{\n` +
+        `${body}\n` +
+        `${classIndent}}`;
+    const lines = ['using Godot;', ''];
+    if (opts.namespaceName) {
+        lines.push(`namespace ${toDotnetNamespace(opts.namespaceName)};`, '');
+    }
+    lines.push(classBlock, '');
+    return lines.join('\n');
+}

package/package.json

@@ -0,0 +1,110 @@
+{
+  "name": "@beremaran/godot-agent-loop",
+  "version": "1.0.0",
+  "description": "Evidence-first MCP automation loop with 167 tested tools for Godot 4",
+  "keywords": [
+    "godot",
+    "mcp",
+    "ai",
+    "claude",
+    "cline",
+    "game-engine",
+    "gdscript",
+    "runtime",
+    "agent-workflows",
+    "evidence-first",
+    "model-context-protocol",
+    "pi-package"
+  ],
+  "homepage": "https://github.com/beremaran/godot-agent-loop",
+  "bugs": {
+    "url": "https://github.com/beremaran/godot-agent-loop/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/beremaran/godot-agent-loop.git"
+  },
+  "mcpName": "io.github.beremaran/godot-agent-loop",
+  "license": "MIT",
+  "author": "Berke Arslan",
+  "contributors": [
+    "Tuğcan Topaloğlu (https://github.com/tugcantopaloglu)",
+    "Solomon Elias <solomon@sippy.ai> (https://github.com/Coding-Solo)"
+  ],
+  "type": "module",
+  "bin": {
+    "godot-agent-loop": "./build/index.js"
+  },
+  "files": [
+    "build",
+    "agent-plugin",
+    "addons/godot_agent_loop",
+    "product.json",
+    "scripts/prepare-package.js"
+  ],
+  "scripts": {
+    "build": "tsc && node scripts/sync-product-metadata.js && node scripts/sync-agent-adapters.js && node scripts/build.js",
+    "product:sync": "node scripts/sync-product-metadata.js --write && npm run adapters:sync",
+    "product:check": "node scripts/sync-product-metadata.js",
+    "adapters:sync": "node scripts/sync-agent-adapters.js --write && npm install --package-lock-only --ignore-scripts",
+    "adapters:check": "node scripts/sync-agent-adapters.js",
+    "inspector": "npx @modelcontextprotocol/inspector build/index.js",
+    "prepare": "node scripts/prepare-package.js",
+    "check": "npm test && npm run lint && npm run coverage:check",
+    "coverage:report": "npm run build && node scripts/generate-coverage-report.js",
+    "coverage:check": "npm run build && node scripts/generate-coverage-report.js --check && npm run coverage:engine -- --check",
+    "coverage:engine": "node scripts/engine-surface-audit.js",
+    "benchmark:loop": "npm run build && node scripts/benchmark-authoring-loop.mjs && npm run coverage:report",
+    "watch": "tsc --watch",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:godot": "npm run test:godot:typecheck && npm run test:godot:validate-script && npm run test:godot:operations && npm run test:godot:runtime && npm run test:godot:launch-demo",
+    "test:godot:typecheck": "tests/godot/run-typecheck.sh",
+    "test:godot:validate-script": "tests/godot/run-validate-script.sh",
+    "test:godot:operations": "tests/godot/run-headless-operations.sh",
+    "test:godot:runtime": "tests/godot/run-integration-tests.sh",
+    "test:godot:launch-demo": "tests/godot/run-launch-demo.sh",
+    "lint": "eslint . && npm run lint:md",
+    "lint:md": "markdownlint-cli2 \"**/*.md\" \"#node_modules\"",
+    "lint:md:fix": "markdownlint-cli2 --fix \"**/*.md\" \"#node_modules\"",
+    "test:e2e": "npm run build && vitest run --config vitest.e2e.config.ts",
+    "test:golden-agent": "npm run build && vitest run --config vitest.e2e.config.ts tests/e2e/golden-agent-game.test.ts",
+    "assetlib:pack": "node scripts/build-assetlib-archive.js",
+    "assetlib:preview": "node scripts/capture-addon-preview.js",
+    "assetlib:submission": "node scripts/build-assetlib-submission.js",
+    "launch:video": "node scripts/build-launch-video.js",
+    "release:candidate": "node scripts/build-release-candidate.js"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.29.0",
+    "jsonc-parser": "^3.3.1",
+    "pngjs": "^7.0.0"
+  },
+  "devDependencies": {
+    "@eslint/js": "^10.0.1",
+    "@types/node": "^20.19.43",
+    "@types/pngjs": "^6.0.5",
+    "@types/yazl": "^3.3.1",
+    "@typescript-eslint/eslint-plugin": "^8.63.0",
+    "@typescript-eslint/parser": "^8.63.0",
+    "@vitest/coverage-v8": "^4.1.10",
+    "eslint": "^10.7.0",
+    "husky": "^9.1.7",
+    "markdownlint-cli2": "^0.23.0",
+    "typescript": "^5.3.3",
+    "typescript-eslint": "^8.63.0",
+    "vitest": "^4.1.10",
+    "yazl": "^3.3.1"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "pi": {
+    "extensions": [
+      "./agent-plugin/pi/extension.ts"
+    ],
+    "skills": [
+      "./agent-plugin/skills"
+    ]
+  }
+}

package/product.json

@@ -0,0 +1,52 @@
+{
+  "$schema": "./docs/product.schema.json",
+  "schemaVersion": 1,
+  "name": "Godot Agent Loop",
+  "tagline": "Build it. Play it. Prove it.",
+  "category": "An evidence-first MCP automation loop for Godot 4",
+  "description": "Evidence-first MCP automation loop with 167 tested tools for Godot 4",
+  "version": "1.0.0",
+  "repository": {
+    "owner": "beremaran",
+    "name": "godot-agent-loop",
+    "url": "https://github.com/beremaran/godot-agent-loop",
+    "issues": "https://github.com/beremaran/godot-agent-loop/issues"
+  },
+  "npm": {
+    "package": "@beremaran/godot-agent-loop",
+    "binary": "godot-agent-loop"
+  },
+  "mcp": {
+    "registryName": "io.github.beremaran/godot-agent-loop",
+    "serverName": "godot-agent-loop",
+    "title": "Godot Agent Loop"
+  },
+  "agentBundle": {
+    "root": "agent-plugin",
+    "pluginName": "godot-agent-loop",
+    "serverKey": "godot-agent-loop"
+  },
+  "addon": {
+    "directory": "addons/godot_agent_loop",
+    "name": "Godot Agent Loop Bridge",
+    "category": "Addons/Tools",
+    "minimumGodotVersion": "4.4",
+    "primaryGodotVersion": "4.7",
+    "protocolVersion": "1",
+    "license": "MIT",
+    "description": "Authenticated editor companion with live agent activity, compatibility status, setup help, and human Pause/Resume control.",
+    "icon": "assets/previews/assetlib-icon.png",
+    "previews": [
+      "assets/previews/assetlib-editor-overview.png",
+      "assets/previews/assetlib-editor-dock.png"
+    ]
+  },
+  "observability": {
+    "serverComponent": "godot-agent-loop-server",
+    "runtimeComponent": "godot-agent-loop-runtime"
+  },
+  "lineage": {
+    "originalRepository": "https://github.com/Coding-Solo/godot-mcp",
+    "inheritedRepository": "https://github.com/tugcantopaloglu/godot-mcp"
+  }
+}