auvrynt 1.0.2 → 1.0.5

package/dist/integrations/context7/context7-tools.js

@@ -0,0 +1,106 @@
+import * as z from "zod/v4";
+import { registerAppTool } from "../../server/mcp-tool-registrar.js";
+import { resolveContext7ApiKey, summarizeContext7Auth, } from "../../infrastructure/context7-auth.js";
+const READ_ONLY = { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true };
+function text(payload, isError = false) {
+    return {
+        content: [{ type: "text", text: typeof payload === "string" ? payload : JSON.stringify(payload, null, 2) }],
+        ...(isError ? { isError: true } : {}),
+    };
+}
+async function context7Get(path, params) {
+    const key = resolveContext7ApiKey();
+    if (!key) {
+        throw new Error("Context7 API key is not configured. Add it in the Secrets tab or set AUVRYNT_CONTEXT7_API_KEY.");
+    }
+    const url = new URL(`https://context7.com${path}`);
+    for (const [param, value] of Object.entries(params)) {
+        if (value)
+            url.searchParams.set(param, value);
+    }
+    const response = await fetch(url, {
+        headers: {
+            Authorization: `Bearer ${key}`,
+            Accept: "application/json",
+        },
+        signal: AbortSignal.timeout(30_000),
+    });
+    const body = await response.text();
+    let parsed = body;
+    try {
+        parsed = JSON.parse(body);
+    }
+    catch {
+        // keep raw text
+    }
+    if (!response.ok) {
+        const message = typeof parsed === "object" && parsed && "message" in parsed
+            ? String(parsed.message)
+            : body.slice(0, 500);
+        throw new Error(`Context7 HTTP ${response.status}: ${message}`);
+    }
+    return parsed;
+}
+export function registerContext7Tools(server) {
+    registerAppTool(server, "context7_resolve_library", {
+        title: "Resolve Context7 library",
+        description: "Search Context7 for a library by name and return matching library IDs (e.g. /vercel/next.js). Use before context7_query_docs when the exact ID is unknown.",
+        inputSchema: {
+            libraryName: z.string().min(1).describe("Library or package name to search for (e.g. next.js, react, zod)."),
+            query: z.string().optional().describe("Optional task/question used to rank matches by relevance."),
+        },
+        annotations: READ_ONLY,
+        _meta: {},
+    }, async ({ libraryName, query }) => {
+        try {
+            const data = await context7Get("/api/v2/libs/search", {
+                libraryName,
+                query: query ?? libraryName,
+            });
+            return text(data);
+        }
+        catch (error) {
+            return text(error instanceof Error ? error.message : String(error), true);
+        }
+    });
+    registerAppTool(server, "context7_query_docs", {
+        title: "Query Context7 docs",
+        description: "Fetch up-to-date documentation snippets for a Context7 library ID. Prefer resolve_library first when the ID is unknown.",
+        inputSchema: {
+            libraryId: z
+                .string()
+                .min(2)
+                .describe("Exact Context7 library ID such as /vercel/next.js or /mongodb/docs."),
+            query: z.string().min(1).describe("Natural-language question or task to retrieve relevant docs for."),
+            type: z.enum(["json", "txt"]).optional().describe("Response type. Defaults to json."),
+        },
+        annotations: READ_ONLY,
+        _meta: {},
+    }, async ({ libraryId, query, type }) => {
+        try {
+            const data = await context7Get("/api/v2/context", {
+                libraryId,
+                query,
+                type: type ?? "json",
+            });
+            return text(data);
+        }
+        catch (error) {
+            return text(error instanceof Error ? error.message : String(error), true);
+        }
+    });
+    registerAppTool(server, "context7_status", {
+        title: "Context7 status",
+        description: "Report whether a Context7 API key is configured (fingerprint only; the key is never returned).",
+        inputSchema: {},
+        annotations: READ_ONLY,
+        _meta: {},
+    }, async () => {
+        const summary = summarizeContext7Auth();
+        return text({
+            configured: summary.configured,
+            fingerprint: summary.fingerprint ?? null,
+            environmentOverride: summary.environmentOverride,
+        });
+    });
+}

package/dist/integrations/dotnet/dotnet-tools.js

@@ -0,0 +1,195 @@
+import { readFile } from "node:fs/promises";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { dirname } from "node:path";
+const execFileAsync = promisify(execFile);
+export function parseDotnetBuildOutput(output) {
+    const errors = [];
+    const warnings = [];
+    const lines = output.split(/\r?\n/);
+    const diagRegex = /^(.*?)\((\d+),(\d+)\):\s*(error|warning)\s*([A-Z0-9]+)?:\s*(.*?)(?:\[.*\])?$/;
+    for (const line of lines) {
+        const match = line.trim().match(diagRegex);
+        if (match) {
+            const [, filePath, lineNum, colNum, severity, code, message] = match;
+            const diag = {
+                path: filePath,
+                line: Number(lineNum),
+                column: Number(colNum),
+                code: code ?? undefined,
+                message: message.trim(),
+            };
+            if (severity.toLowerCase() === "error")
+                errors.push(diag);
+            else
+                warnings.push(diag);
+        }
+    }
+    const success = errors.length === 0 && !output.includes("Build FAILED");
+    return { success, errors, warnings };
+}
+export function parseDotnetTestOutput(output) {
+    let passed = 0;
+    let failed = 0;
+    let skipped = 0;
+    const failedTestNames = [];
+    const assertionMessages = [];
+    const summaryMatch = output.match(/Failed:\s*(\d+),\s*Passed:\s*(\d+),\s*Skipped:\s*(\d+)/i);
+    if (summaryMatch) {
+        failed = Number(summaryMatch[1]);
+        passed = Number(summaryMatch[2]);
+        skipped = Number(summaryMatch[3]);
+    }
+    const lines = output.split(/\r?\n/);
+    for (const line of lines) {
+        if (line.includes("Failed ") || line.includes("Failed:")) {
+            const nameMatch = line.match(/Failed\s+([A-Za-z0-9_.]+)/);
+            if (nameMatch && !failedTestNames.includes(nameMatch[1]))
+                failedTestNames.push(nameMatch[1]);
+        }
+        if (line.includes("Assert.") || line.includes("Expected:") || line.includes("Actual:")) {
+            assertionMessages.push(line.trim());
+        }
+    }
+    return { passed, failed, skipped, failedTestNames, assertionMessages };
+}
+export async function inspectDotnetProject(registry, input) {
+    const workspace = registry.getWorkspace(input.workspaceId);
+    const absolutePath = registry.resolvePath(workspace, input.projectPath);
+    let xmlContent = "";
+    try {
+        xmlContent = await readFile(absolutePath, "utf8");
+    }
+    catch {
+        throw new Error(`Unable to read .NET project file: ${input.projectPath}`);
+    }
+    const sdkStyle = xmlContent.includes('<Project Sdk=') || xmlContent.includes('Sdk="Microsoft.NET.Sdk');
+    const tfmMatch = xmlContent.match(/<TargetFrameworks?>(.*?)<\/TargetFrameworks?>/i);
+    const targetFrameworks = tfmMatch ? tfmMatch[1].split(";").map((t) => t.trim()) : [];
+    const outputTypeMatch = xmlContent.match(/<OutputType>(.*?)<\/OutputType>/i);
+    const outputType = outputTypeMatch ? outputTypeMatch[1].trim() : "Exe";
+    const nullableMatch = xmlContent.match(/<Nullable>(.*?)<\/Nullable>/i);
+    const nullable = nullableMatch ? nullableMatch[1].trim() : "enable";
+    const implicitUsingsMatch = xmlContent.match(/<ImplicitUsings>(.*?)<\/ImplicitUsings>/i);
+    const implicitUsings = implicitUsingsMatch ? implicitUsingsMatch[1].trim() : "enable";
+    const packageReferences = [];
+    const pkgRegex = /<PackageReference\s+Include="([^"]+)"/g;
+    let pkgMatch;
+    while ((pkgMatch = pkgRegex.exec(xmlContent)) !== null)
+        packageReferences.push(pkgMatch[1]);
+    const projectReferences = [];
+    const projRefRegex = /<ProjectReference\s+Include="([^"]+)"/g;
+    let projRefMatch;
+    while ((projRefMatch = projRefRegex.exec(xmlContent)) !== null)
+        projectReferences.push(projRefMatch[1]);
+    let testFramework;
+    if (packageReferences.some((p) => p.includes("xunit")))
+        testFramework = "xUnit";
+    else if (packageReferences.some((p) => p.includes("nunit")))
+        testFramework = "NUnit";
+    else if (packageReferences.some((p) => p.includes("MSTest")))
+        testFramework = "MSTest";
+    return {
+        projectPath: input.projectPath,
+        sdkStyle,
+        targetFrameworks,
+        outputType,
+        nullable,
+        implicitUsings,
+        packageReferences,
+        projectReferences,
+        testFramework,
+    };
+}
+export async function dotnetRestore(registry, input) {
+    const workspace = registry.getWorkspace(input.workspaceId);
+    const absolutePath = registry.resolvePath(workspace, input.projectPath);
+    const cwd = dirname(absolutePath);
+    const start = Date.now();
+    try {
+        const { stdout, stderr } = await execFileAsync("dotnet", ["restore", absolutePath], { cwd, windowsHide: true });
+        return { success: true, durationMs: Date.now() - start, output: (stdout + "\n" + stderr).slice(0, 1000) };
+    }
+    catch (err) {
+        return {
+            success: false,
+            durationMs: Date.now() - start,
+            output: (err.stdout ?? "") + "\n" + (err.stderr ?? err.message),
+        };
+    }
+}
+export async function dotnetBuild(registry, input) {
+    const workspace = registry.getWorkspace(input.workspaceId);
+    const absolutePath = registry.resolvePath(workspace, input.projectPath);
+    const cwd = dirname(absolutePath);
+    const args = ["build", absolutePath];
+    if (input.configuration)
+        args.push("-c", input.configuration);
+    if (input.noRestore)
+        args.push("--no-restore");
+    const start = Date.now();
+    try {
+        const { stdout, stderr } = await execFileAsync("dotnet", args, { cwd, windowsHide: true });
+        const parsed = parseDotnetBuildOutput(stdout + "\n" + stderr);
+        return { success: parsed.success, durationMs: Date.now() - start, errors: parsed.errors, warnings: parsed.warnings };
+    }
+    catch (err) {
+        const parsed = parseDotnetBuildOutput((err.stdout ?? "") + "\n" + (err.stderr ?? err.message));
+        return {
+            success: false,
+            durationMs: Date.now() - start,
+            errors: parsed.errors.length > 0 ? parsed.errors : [{ message: err.message }],
+            warnings: parsed.warnings,
+        };
+    }
+}
+export async function dotnetTest(registry, input) {
+    const workspace = registry.getWorkspace(input.workspaceId);
+    const absolutePath = registry.resolvePath(workspace, input.projectPath);
+    const cwd = dirname(absolutePath);
+    const args = ["test", absolutePath];
+    if (input.configuration)
+        args.push("-c", input.configuration);
+    if (input.filter)
+        args.push("--filter", input.filter);
+    if (input.noBuild)
+        args.push("--no-build");
+    const start = Date.now();
+    try {
+        const { stdout, stderr } = await execFileAsync("dotnet", args, { cwd, windowsHide: true });
+        return { ...parseDotnetTestOutput(stdout + "\n" + stderr), durationMs: Date.now() - start };
+    }
+    catch (err) {
+        return {
+            ...parseDotnetTestOutput((err.stdout ?? "") + "\n" + (err.stderr ?? err.message)),
+            durationMs: Date.now() - start,
+        };
+    }
+}
+export async function dotnetRun(registry, processManager, input) {
+    const workspace = registry.getWorkspace(input.workspaceId);
+    const absolutePath = registry.resolvePath(workspace, input.projectPath);
+    const configArg = input.configuration ? `-c ${input.configuration}` : "";
+    const extraArgs = input.arguments?.length ? `-- ${input.arguments.join(" ")}` : "";
+    const command = `dotnet run --project "${absolutePath}" ${configArg} ${extraArgs}`.trim();
+    const result = processManager.startProcess({
+        workspaceId: input.workspaceId,
+        command,
+        environment: input.environment,
+    });
+    return { processId: result.processId, status: result.status, detectedUrls: result.detectedUrls };
+}
+export async function dotnetFormat(registry, input) {
+    const workspace = registry.getWorkspace(input.workspaceId);
+    const absolutePath = registry.resolvePath(workspace, input.projectPath);
+    const args = ["format", absolutePath];
+    if (input.verifyOnly)
+        args.push("--verify-no-changes");
+    try {
+        const { stdout, stderr } = await execFileAsync("dotnet", args, { cwd: dirname(absolutePath), windowsHide: true });
+        return { success: true, output: (stdout + "\n" + stderr).slice(0, 1000) };
+    }
+    catch (err) {
+        return { success: false, output: (err.stdout ?? "") + "\n" + (err.stderr ?? err.message) };
+    }
+}

package/dist/integrations/godot/godot-animation-tilemap.js

@@ -0,0 +1,74 @@
+export async function listAnimations(input, bridgeClient) {
+    if (!bridgeClient.status)
+        throw new Error("Godot Editor Bridge is not connected.");
+    const result = await bridgeClient.sendRequest("animation.list", { nodePath: input.animationPlayerNodePath });
+    return result.animations ?? [];
+}
+export async function getAnimation(input, bridgeClient) {
+    if (!bridgeClient.status)
+        throw new Error("Godot Editor Bridge is not connected.");
+    return bridgeClient.sendRequest("animation.get", {
+        nodePath: input.animationPlayerNodePath,
+        animationName: input.animationName,
+    });
+}
+export async function createAnimation(input, bridgeClient) {
+    if (!bridgeClient.status)
+        throw new Error("Godot Editor Bridge is not connected.");
+    await bridgeClient.sendRequest("animation.create", {
+        nodePath: input.animationPlayerNodePath,
+        animationName: input.animationName,
+        length: input.lengthSeconds ?? 1,
+        loop: input.loop ?? false,
+    });
+    return { created: true, name: input.animationName };
+}
+export async function validateAnimation(input, bridgeClient) {
+    if (!bridgeClient.status)
+        throw new Error("Godot Editor Bridge is not connected.");
+    const animation = await getAnimation(input, bridgeClient);
+    const issues = [];
+    if (animation.lengthSeconds === 0)
+        issues.push("Animation length is zero.");
+    for (const track of animation.tracks) {
+        if (track.keys.length === 0)
+            issues.push(`Track '${track.targetPath}' has no keys.`);
+    }
+    return { valid: issues.length === 0, issues };
+}
+export async function getTileLayers(input, bridgeClient) {
+    if (!bridgeClient.status)
+        throw new Error("Godot Editor Bridge is not connected.");
+    const result = await bridgeClient.sendRequest("tilemap.get_layers", { nodePath: input.tileMapNodePath });
+    return result.layers ?? [];
+}
+export async function inspectTileset(input, bridgeClient) {
+    if (!bridgeClient.status)
+        throw new Error("Godot Editor Bridge is not connected.");
+    return bridgeClient.sendRequest("tilemap.inspect_tileset", { nodePath: input.tileMapNodePath });
+}
+export async function validateTilemap(input, bridgeClient) {
+    if (!bridgeClient.status)
+        throw new Error("Godot Editor Bridge is not connected.");
+    return bridgeClient.sendRequest("tilemap.validate", { nodePath: input.tileMapNodePath });
+}
+export async function getPhysicsConfiguration(input, bridgeClient) {
+    if (!bridgeClient.status)
+        throw new Error("Godot Editor Bridge is not connected.");
+    return bridgeClient.sendRequest("physics.get_configuration", { nodePath: input.nodePath ?? "/" });
+}
+export async function validateCollisions(input, bridgeClient) {
+    if (!bridgeClient.status)
+        throw new Error("Godot Editor Bridge is not connected.");
+    return bridgeClient.sendRequest("physics.validate_collisions", { nodePath: input.nodePath ?? "/" });
+}
+export async function getCameraState(input, bridgeClient) {
+    if (!bridgeClient.status)
+        throw new Error("Godot Editor Bridge is not connected.");
+    return bridgeClient.sendRequest("camera.get_state", { nodePath: input.cameraNodePath });
+}
+export async function validateCamera(input, bridgeClient) {
+    if (!bridgeClient.status)
+        throw new Error("Godot Editor Bridge is not connected.");
+    return bridgeClient.sendRequest("camera.validate", { nodePath: input.cameraNodePath });
+}

package/dist/integrations/godot/godot-csharp-build.js

@@ -0,0 +1,91 @@
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { dirname } from "node:path";
+import { parseDotnetBuildOutput } from "../../dotnet-tools.js";
+import { inspectGodotDotnetProject } from "./godot-csharp-project.js";
+const execFileAsync = promisify(execFile);
+export function parseGodotBuildDiagnostics(output) {
+    const base = parseDotnetBuildOutput(output);
+    const mapDiag = (d) => {
+        let source = "csharp";
+        if (d.code?.startsWith("CS"))
+            source = "csharp";
+        else if (d.code?.startsWith("MSB"))
+            source = "msbuild";
+        else if (d.code?.startsWith("NU"))
+            source = "nuget";
+        else if (d.message.toLowerCase().includes("godot"))
+            source = "godot";
+        return {
+            source,
+            code: d.code,
+            message: d.message,
+            path: d.path,
+            line: d.line,
+            column: d.column,
+        };
+    };
+    return {
+        success: base.success,
+        errors: base.errors.map(mapDiag),
+        warnings: base.warnings.map(mapDiag),
+    };
+}
+export async function godotDotnetBuild(registry, input) {
+    const workspace = registry.getWorkspace(input.workspaceId);
+    const targetDir = registry.resolvePath(workspace, input.projectPath);
+    const details = await inspectGodotDotnetProject(registry, { workspaceId: input.workspaceId, projectPath: input.projectPath });
+    const buildTarget = details.slnPath ? registry.resolvePath(workspace, details.slnPath) : (details.csprojPath ? registry.resolvePath(workspace, details.csprojPath) : targetDir);
+    const config = input.configuration ?? "Debug";
+    const args = ["build", buildTarget, "-c", config];
+    if (input.noRestore)
+        args.push("--no-restore");
+    const start = Date.now();
+    try {
+        const { stdout, stderr } = await execFileAsync("dotnet", args, { cwd: dirname(buildTarget), windowsHide: true });
+        const parsed = parseGodotBuildDiagnostics(stdout + "\n" + stderr);
+        return {
+            success: parsed.success,
+            configuration: config,
+            targetFrameworks: details.targetFrameworks,
+            outputAssemblies: details.assemblyName ? [`${details.assemblyName}.dll`] : [],
+            errors: parsed.errors,
+            warnings: parsed.warnings,
+            durationMs: Date.now() - start,
+        };
+    }
+    catch (err) {
+        const parsed = parseGodotBuildDiagnostics((err.stdout ?? "") + "\n" + (err.stderr ?? err.message));
+        return {
+            success: false,
+            configuration: config,
+            targetFrameworks: details.targetFrameworks,
+            outputAssemblies: [],
+            errors: parsed.errors.length > 0 ? parsed.errors : [{ source: "csharp", message: err.message }],
+            warnings: parsed.warnings,
+            durationMs: Date.now() - start,
+        };
+    }
+}
+export async function godotDotnetClean(registry, input) {
+    const workspace = registry.getWorkspace(input.workspaceId);
+    const targetDir = registry.resolvePath(workspace, input.projectPath);
+    const config = input.configuration ?? "Debug";
+    const args = ["clean", targetDir, "-c", config];
+    const start = Date.now();
+    try {
+        const { stdout, stderr } = await execFileAsync("dotnet", args, { cwd: targetDir, windowsHide: true });
+        return {
+            success: true,
+            durationMs: Date.now() - start,
+            output: (stdout + "\n" + stderr).slice(0, 1000),
+        };
+    }
+    catch (err) {
+        return {
+            success: false,
+            durationMs: Date.now() - start,
+            output: (err.stdout ?? "") + "\n" + (err.stderr ?? err.message),
+        };
+    }
+}

package/dist/integrations/godot/godot-csharp-project.js

@@ -0,0 +1,155 @@
+import { readdir, readFile } from "node:fs/promises";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { join, relative } from "node:path";
+import { parseGodotProjectFile } from "./godot-tools.js";
+const execFileAsync = promisify(execFile);
+export async function inspectGodotDotnetProject(registry, input) {
+    const workspace = registry.getWorkspace(input.workspaceId);
+    const targetDir = input.projectPath
+        ? registry.resolvePath(workspace, input.projectPath)
+        : workspace.root;
+    const projectGodotPath = join(targetDir, "project.godot");
+    let projectGodotContent = "";
+    try {
+        projectGodotContent = await readFile(projectGodotPath, "utf8");
+    }
+    catch {
+        throw new Error(`project.godot not found in directory: ${input.projectPath ?? "."}`);
+    }
+    const parsedGodot = parseGodotProjectFile(projectGodotContent);
+    let csharpScriptCount = 0;
+    let gdscriptCount = 0;
+    let csprojFile;
+    let slnFile;
+    async function scanDir(dir) {
+        let entries;
+        try {
+            entries = await readdir(dir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            if (entry.isDirectory()) {
+                if ([".godot", "bin", "obj", "node_modules", ".git"].includes(entry.name))
+                    continue;
+                await scanDir(join(dir, entry.name));
+            }
+            else if (entry.isFile()) {
+                if (entry.name.endsWith(".cs"))
+                    csharpScriptCount++;
+                else if (entry.name.endsWith(".gd"))
+                    gdscriptCount++;
+                else if (entry.name.endsWith(".csproj"))
+                    csprojFile = join(dir, entry.name);
+                else if (entry.name.endsWith(".sln"))
+                    slnFile = join(dir, entry.name);
+            }
+        }
+    }
+    await scanDir(targetDir);
+    let targetFrameworks = [];
+    let godotNetSdkVersion;
+    const packageReferences = [];
+    const projectReferences = [];
+    const nullable = "enable";
+    const implicitUsings = "enable";
+    let rootNamespace;
+    let assemblyName;
+    if (csprojFile) {
+        try {
+            const xml = await readFile(csprojFile, "utf8");
+            const tfmMatch = xml.match(/<TargetFrameworks?>(.*?)<\/TargetFrameworks?>/i);
+            if (tfmMatch)
+                targetFrameworks = tfmMatch[1].split(";").map((t) => t.trim());
+            const sdkMatch = xml.match(/Godot\.NET\.Sdk\/([0-9.]+)/i);
+            if (sdkMatch)
+                godotNetSdkVersion = sdkMatch[1];
+            const nsMatch = xml.match(/<RootNamespace>(.*?)<\/RootNamespace>/i);
+            if (nsMatch)
+                rootNamespace = nsMatch[1].trim();
+            const asmMatch = xml.match(/<AssemblyName>(.*?)<\/AssemblyName>/i);
+            if (asmMatch)
+                assemblyName = asmMatch[1].trim();
+            const pkgRegex = /<PackageReference\s+Include="([^"]+)"/g;
+            let match;
+            while ((match = pkgRegex.exec(xml)) !== null)
+                packageReferences.push(match[1]);
+        }
+        catch { }
+    }
+    const isMixedLanguage = csharpScriptCount > 0 && gdscriptCount > 0;
+    const requiresSolutionRegeneration = !slnFile || !csprojFile;
+    return {
+        projectGodotPath: relative(workspace.root, projectGodotPath).replace(/\\/g, "/"),
+        name: parsedGodot.name,
+        mainScene: parsedGodot.mainScene,
+        renderer: parsedGodot.renderer,
+        godotVersionFeatures: parsedGodot.features,
+        csprojPath: csprojFile ? relative(workspace.root, csprojFile).replace(/\\/g, "/") : undefined,
+        slnPath: slnFile ? relative(workspace.root, slnFile).replace(/\\/g, "/") : undefined,
+        targetFrameworks,
+        godotNetSdkVersion,
+        packageReferences,
+        projectReferences,
+        nullable,
+        implicitUsings,
+        rootNamespace,
+        assemblyName,
+        autoloads: parsedGodot.autoloads,
+        inputActions: parsedGodot.inputActions,
+        csharpScriptCount,
+        gdscriptCount,
+        isMixedLanguage,
+        requiresSolutionRegeneration,
+    };
+}
+export async function godotBuildSolutions(registry, input) {
+    const workspace = registry.getWorkspace(input.workspaceId);
+    const targetDir = registry.resolvePath(workspace, input.projectPath);
+    const godotExe = process.env.GODOT_DOTNET_EXECUTABLE ?? process.env.GODOT_EXECUTABLE ?? "godot-mono";
+    const args = ["--headless", "--path", targetDir, "--build-solutions", "--quit"];
+    const start = Date.now();
+    try {
+        const { stdout, stderr } = await execFileAsync(godotExe, args, { cwd: targetDir, windowsHide: true });
+        const details = await inspectGodotDotnetProject(registry, { workspaceId: input.workspaceId, projectPath: input.projectPath });
+        return {
+            success: true,
+            durationMs: Date.now() - start,
+            generatedSln: details.slnPath,
+            generatedCsproj: details.csprojPath,
+            output: (stdout + "\n" + stderr).slice(0, 1000),
+        };
+    }
+    catch (err) {
+        return {
+            success: false,
+            durationMs: Date.now() - start,
+            output: (err.stdout ?? "") + "\n" + (err.stderr ?? err.message),
+        };
+    }
+}
+export async function godotDotnetRestore(registry, input) {
+    const workspace = registry.getWorkspace(input.workspaceId);
+    const targetDir = registry.resolvePath(workspace, input.projectPath);
+    const args = ["restore", targetDir];
+    if (input.lockedMode)
+        args.push("--locked-mode");
+    const start = Date.now();
+    try {
+        const { stdout, stderr } = await execFileAsync("dotnet", args, { cwd: targetDir, windowsHide: true });
+        return {
+            success: true,
+            durationMs: Date.now() - start,
+            output: (stdout + "\n" + stderr).slice(0, 1000),
+        };
+    }
+    catch (err) {
+        return {
+            success: false,
+            durationMs: Date.now() - start,
+            output: (err.stdout ?? "") + "\n" + (err.stderr ?? err.message),
+        };
+    }
+}