auvrynt 1.0.2 → 1.0.5

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

@@ -0,0 +1,118 @@
+import { inspectGodotDotnetProject } from "./godot-csharp-project.js";
+export async function godotRunProject(registry, processManager, input) {
+    const workspace = registry.getWorkspace(input.workspaceId);
+    const projectDir = registry.resolvePath(workspace, input.projectPath);
+    const details = await inspectGodotDotnetProject(registry, { workspaceId: input.workspaceId, projectPath: input.projectPath });
+    const godotExe = process.env.GODOT_DOTNET_EXECUTABLE ?? process.env.GODOT_EXECUTABLE ?? "godot-mono";
+    const args = ["--path", `"${projectDir}"`];
+    if (input.debug ?? true)
+        args.push("-d");
+    if (input.windowed)
+        args.push("-w");
+    if (input.resolution)
+        args.push("--resolution", `${input.resolution.width}x${input.resolution.height}`);
+    if (input.additionalGodotArguments)
+        args.push(...input.additionalGodotArguments);
+    if (input.userArguments && input.userArguments.length > 0)
+        args.push("--", ...input.userArguments);
+    const result = processManager.startProcess({
+        workspaceId: input.workspaceId,
+        command: `${godotExe} ${args.join(" ")}`,
+        workingDirectory: projectDir,
+    });
+    return {
+        processId: result.processId,
+        status: result.status,
+        windowDetected: !args.includes("--headless"),
+        projectName: details.name,
+    };
+}
+export async function godotRunScene(registry, processManager, input) {
+    const workspace = registry.getWorkspace(input.workspaceId);
+    const projectDir = registry.resolvePath(workspace, input.projectPath);
+    const absoluteScene = registry.resolvePath(workspace, input.scenePath);
+    if (!input.scenePath.endsWith(".tscn")) {
+        throw new Error(`Invalid scene file extension: ${input.scenePath}. Only .tscn text scenes are supported.`);
+    }
+    const godotExe = process.env.GODOT_DOTNET_EXECUTABLE ?? process.env.GODOT_EXECUTABLE ?? "godot-mono";
+    const args = ["--path", `"${projectDir}"`, `"${absoluteScene}"`];
+    if (input.debug ?? true)
+        args.push("-d");
+    const result = processManager.startProcess({
+        workspaceId: input.workspaceId,
+        command: `${godotExe} ${args.join(" ")}`,
+        workingDirectory: projectDir,
+    });
+    return { processId: result.processId, status: result.status };
+}
+export function parseStructuredRuntimeLogs(rawLines) {
+    const entries = [];
+    let currentEntry = null;
+    for (const line of rawLines) {
+        const trimmed = line.trim();
+        if (!trimmed)
+            continue;
+        if (trimmed.includes("Exception:") || trimmed.startsWith("System.") || trimmed.includes("NullReferenceException") || trimmed.includes("InvalidCastException")) {
+            if (currentEntry)
+                entries.push(currentEntry);
+            currentEntry = {
+                severity: "error",
+                category: "csharp_exception",
+                message: trimmed,
+                stackFrames: [],
+            };
+            continue;
+        }
+        const stackMatch = trimmed.match(/^at\s+(.*?)(?:\s+in\s+(.*?):line\s+(\d+))?$/);
+        if (stackMatch && currentEntry && currentEntry.category === "csharp_exception") {
+            currentEntry.stackFrames = currentEntry.stackFrames ?? [];
+            currentEntry.stackFrames.push({
+                method: stackMatch[1],
+                path: stackMatch[2],
+                line: stackMatch[3] ? Number(stackMatch[3]) : undefined,
+            });
+            continue;
+        }
+        if (trimmed.includes("ERROR:") || trimmed.includes("SCRIPT ERROR:")) {
+            if (currentEntry)
+                entries.push(currentEntry);
+            currentEntry = { severity: "error", category: "godot_error", message: trimmed };
+        }
+        else if (trimmed.includes("WARNING:")) {
+            if (currentEntry)
+                entries.push(currentEntry);
+            currentEntry = { severity: "warning", category: "godot_warning", message: trimmed };
+        }
+        else {
+            if (currentEntry && currentEntry.category !== "print") {
+                entries.push(currentEntry);
+                currentEntry = null;
+            }
+            entries.push({ severity: "print", category: "gd_print", message: trimmed });
+        }
+    }
+    if (currentEntry)
+        entries.push(currentEntry);
+    const grouped = [];
+    for (const entry of entries) {
+        const previous = grouped[grouped.length - 1];
+        if (previous && previous.message === entry.message && previous.severity === entry.severity) {
+            previous.repeatCount = (previous.repeatCount ?? 1) + 1;
+        }
+        else {
+            grouped.push(entry);
+        }
+    }
+    return grouped;
+}
+export function getGodotRuntimeLogs(processManager, input) {
+    const logs = processManager.getProcessLogs({
+        workspaceId: input.workspaceId,
+        processId: input.processId,
+        lines: input.lines ?? 100,
+    });
+    const parsed = parseStructuredRuntimeLogs(logs.lines);
+    const severityFilter = input.severity ? new Set(input.severity) : null;
+    const filtered = severityFilter ? parsed.filter((entry) => severityFilter.has(entry.severity)) : parsed;
+    return { processId: input.processId, entries: filtered, totalEntries: filtered.length };
+}

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

@@ -0,0 +1,146 @@
+import { readdir, readFile } from "node:fs/promises";
+import { join, relative } from "node:path";
+export async function findCsharpClasses(registry, input) {
+    const workspace = registry.getWorkspace(input.workspaceId);
+    const results = [];
+    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.name.endsWith(".cs")) {
+                const filePath = join(dir, entry.name);
+                const content = await readFile(filePath, "utf8").catch(() => "");
+                const info = parseCsharpFile(content, relative(workspace.root, filePath).replace(/\\/g, "/"));
+                for (const cls of info) {
+                    if (cls.className === input.className)
+                        results.push(cls);
+                }
+            }
+        }
+    }
+    await scanDir(workspace.root);
+    return results;
+}
+export function parseCsharpFile(content, filePath) {
+    const classes = [];
+    let namespace;
+    const nsMatch = content.match(/^namespace\s+([\w.]+)/m);
+    if (nsMatch)
+        namespace = nsMatch[1];
+    const classRegex = /^(?:\[[\w,=\s"'.()[\]]*\]\s*)*\s*(public|internal|private|protected)?\s*(static|sealed|abstract)?\s*(partial\s+)?class\s+(\w+)(?:\s*:\s*([\w<>, ]+))?/gm;
+    let match;
+    while ((match = classRegex.exec(content)) !== null) {
+        const inheritance = (match[5] ?? "").split(",").map((value) => value.trim()).filter(Boolean);
+        classes.push({
+            className: match[4],
+            filePath,
+            line: content.slice(0, match.index).split("\n").length,
+            baseClass: inheritance[0] ?? undefined,
+            isPartial: !!match[3],
+            implementedInterfaces: inheritance.slice(1),
+            namespace,
+            exportedProperties: extractExportedProperties(content),
+            signals: extractCsharpSignals(content),
+            lifecycleOverrides: extractLifecycleOverrides(content),
+        });
+    }
+    return classes;
+}
+function extractExportedProperties(content) {
+    const properties = [];
+    const exportRegex = /\[Export(?:Group|Subgroup|Category)?\(?"?(.*?)"?\)?\]\s+(?:public\s+)([\w?<>[\]]+)\s+(\w+)/g;
+    let match;
+    while ((match = exportRegex.exec(content)) !== null) {
+        properties.push({
+            propertyName: match[3],
+            inspectorDisplayName: match[3].replace(/([A-Z])/g, " $1").trim(),
+            type: match[2],
+            exportAttribute: match[0].split("]")[0] + "]",
+            isNullable: match[2].endsWith("?"),
+        });
+    }
+    return properties;
+}
+function extractCsharpSignals(content) {
+    const signals = [];
+    const delegateRegex = /\[Signal\]\s+public\s+delegate\s+void\s+(\w+)\((.*?)\)/g;
+    let match;
+    while ((match = delegateRegex.exec(content)) !== null) {
+        const name = match[1].replace(/EventHandler$/, "");
+        const parameters = match[2] ? match[2].split(",").map((value) => value.trim()) : [];
+        signals.push({ name, parameters, declaration: match[0] });
+    }
+    return signals;
+}
+function extractLifecycleOverrides(content) {
+    const lifecycles = [
+        "_Ready", "_Process", "_PhysicsProcess", "_Input", "_UnhandledInput",
+        "_Draw", "_EnterTree", "_ExitTree", "_Notification", "_GetConfigurationWarnings",
+    ];
+    return lifecycles.filter((lifecycle) => new RegExp(`override.*void.*${lifecycle}\\s*\\(`).test(content));
+}
+export async function getCsharpDiagnostics(registry, input) {
+    const workspace = registry.getWorkspace(input.workspaceId);
+    const targetDir = registry.resolvePath(workspace, input.projectPath);
+    const errors = [];
+    const warnings = [];
+    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"].includes(entry.name))
+                    continue;
+                await scanDir(join(dir, entry.name));
+            }
+            else if (entry.name.endsWith(".cs")) {
+                const filePath = join(dir, entry.name);
+                const content = await readFile(filePath, "utf8").catch(() => "");
+                const relativePath = relative(workspace.root, filePath).replace(/\\/g, "/");
+                if (!content.includes("partial class") && content.includes("extends")) {
+                    warnings.push(`${relativePath}: GDScript-style 'extends' found in .cs file - check syntax.`);
+                }
+            }
+        }
+    }
+    await scanDir(targetDir);
+    return { errors, warnings };
+}
+export async function getExportedProperties(registry, input) {
+    const workspace = registry.getWorkspace(input.workspaceId);
+    const absolutePath = registry.resolvePath(workspace, input.scriptPath);
+    return extractExportedProperties(await readFile(absolutePath, "utf8"));
+}
+export async function generateCsharpScript(params) {
+    const base = params.baseType ?? "Node";
+    const namespaceOpen = params.namespace ? `namespace ${params.namespace}\n{\n` : "";
+    const namespaceClose = params.namespace ? `}\n` : "";
+    const indent = params.namespace ? "    " : "";
+    return [
+        "using Godot;",
+        "",
+        namespaceOpen,
+        `${indent}public partial class ${params.className} : ${base}`,
+        `${indent}{`,
+        `${indent}    public override void _Ready()`,
+        `${indent}    {`,
+        `${indent}    }`,
+        `${indent}}`,
+        namespaceClose,
+    ].join("\n").trim() + "\n";
+}

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

@@ -0,0 +1,71 @@
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { godotDotnetBuild } from "./godot-csharp-build.js";
+import { parseStructuredRuntimeLogs } from "./godot-csharp-runner.js";
+const execFileAsync = promisify(execFile);
+export async function godotValidateProject(registry, input) {
+    const workspace = registry.getWorkspace(input.workspaceId);
+    const targetDir = registry.resolvePath(workspace, input.projectPath);
+    const start = Date.now();
+    let csharpDiagnostics = undefined;
+    if (input.buildCsharpFirst ?? true) {
+        csharpDiagnostics = await godotDotnetBuild(registry, {
+            workspaceId: input.workspaceId,
+            projectPath: input.projectPath,
+        });
+    }
+    const godotExe = process.env.GODOT_DOTNET_EXECUTABLE ?? process.env.GODOT_EXECUTABLE ?? "godot-mono";
+    const args = ["--headless", "--path", targetDir, "--editor", "--quit"];
+    let rawLogs = [];
+    try {
+        const { stdout, stderr } = await execFileAsync(godotExe, args, { cwd: targetDir, windowsHide: true });
+        rawLogs = (stdout + "\n" + stderr).split(/\r?\n/);
+    }
+    catch (err) {
+        rawLogs = ((err.stdout ?? "") + "\n" + (err.stderr ?? err.message)).split(/\r?\n/);
+    }
+    const godotDiagnostics = parseStructuredRuntimeLogs(rawLogs);
+    const missingResources = [];
+    const failedImports = [];
+    for (const entry of godotDiagnostics) {
+        if (entry.message.includes("Resource not found") || entry.message.includes("Failed loading resource")) {
+            missingResources.push(entry.message);
+        }
+        if (entry.message.includes("Import error") || entry.message.includes("Failed to import")) {
+            failedImports.push(entry.message);
+        }
+    }
+    const hasErrors = (csharpDiagnostics && !csharpDiagnostics.success) || godotDiagnostics.some((d) => d.severity === "error");
+    const hasWarnings = godotDiagnostics.some((d) => d.severity === "warning");
+    const status = hasErrors ? "invalid" : (hasWarnings ? "warnings" : "valid");
+    return {
+        status,
+        csharpDiagnostics,
+        godotDiagnostics,
+        missingResources,
+        failedImports,
+        durationMs: Date.now() - start,
+    };
+}
+export async function godotImportAssets(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, "--editor", "--quit"];
+    const start = Date.now();
+    try {
+        const { stdout, stderr } = await execFileAsync(godotExe, 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-dotnet-env.js

@@ -0,0 +1,134 @@
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+const execFileAsync = promisify(execFile);
+export async function detectDotnetSdk() {
+    try {
+        const { stdout } = await execFileAsync("dotnet", ["--info"], { windowsHide: true });
+        const sdkVersions = [];
+        let architecture;
+        for (const line of stdout.split(/\r?\n/)) {
+            if (line.includes("Architecture:"))
+                architecture = line.split(":")[1]?.trim();
+            const sdkMatch = line.trim().match(/^(\d+\.\d+\.\d+)\s+\[/);
+            if (sdkMatch)
+                sdkVersions.push(sdkMatch[1]);
+        }
+        return {
+            dotnetExecutable: "dotnet",
+            dotnetSdkVersions: sdkVersions,
+            selectedDotnetSdk: sdkVersions.at(-1),
+            architecture: architecture ?? process.arch,
+        };
+    }
+    catch {
+        return { dotnetSdkVersions: [], architecture: process.arch };
+    }
+}
+export function findGodotExecutableCandidates() {
+    const candidates = [];
+    if (process.env.GODOT_DOTNET_EXECUTABLE)
+        candidates.push(process.env.GODOT_DOTNET_EXECUTABLE);
+    if (process.env.GODOT_EXECUTABLE)
+        candidates.push(process.env.GODOT_EXECUTABLE);
+    candidates.push("godot-mono", "Godot_v4.6-stable_mono_win64.exe", "Godot_v4.5-stable_mono_win64.exe", "Godot_v4.4-stable_mono_win64.exe", "Godot_v4.3-stable_mono_win64.exe", "Godot_v4.2-stable_mono_win64.exe", "Godot_v4.1-stable_mono_win64.exe", "Godot_v4.0-stable_mono_win64.exe", "godot");
+    const home = homedir();
+    for (const path of [
+        join(home, "scoop", "apps", "godot-mono", "current", "godot.exe"),
+        join(home, "AppData", "Local", "Programs", "Godot", "godot.exe"),
+        "C:\\Program Files\\Godot\\godot.exe",
+    ]) {
+        if (existsSync(path))
+            candidates.push(path);
+    }
+    return Array.from(new Set(candidates));
+}
+export async function verifyGodotExecutable(exePath) {
+    try {
+        const { stdout, stderr } = await execFileAsync(exePath, ["--version"], { windowsHide: true });
+        const output = (stdout + "\n" + stderr).trim();
+        const version = output.split(/\r?\n/)[0] ?? output;
+        const hasDotnetSupport = version.toLowerCase().includes("mono") || output.toLowerCase().includes("mono");
+        return { valid: true, version, hasDotnetSupport };
+    }
+    catch {
+        return { valid: false, hasDotnetSupport: false };
+    }
+}
+export async function inspectGodotDotnetEnvironment(registry, input) {
+    const problems = [];
+    const dotnetInfo = await detectDotnetSdk();
+    if (dotnetInfo.dotnetSdkVersions.length === 0) {
+        problems.push({
+            code: "MISSING_DOTNET_SDK",
+            message: ".NET SDK was not detected or `dotnet` command failed.",
+            suggestedFix: "Install a 64-bit .NET 8.0 SDK from https://dotnet.microsoft.com/download",
+        });
+    }
+    let selectedGodotExe;
+    let selectedGodotVersion;
+    let godotHasDotnetSupport = false;
+    for (const candidate of findGodotExecutableCandidates()) {
+        const check = await verifyGodotExecutable(candidate);
+        if (check.valid) {
+            selectedGodotExe = candidate;
+            selectedGodotVersion = check.version;
+            godotHasDotnetSupport = check.hasDotnetSupport;
+            if (godotHasDotnetSupport)
+                break;
+        }
+    }
+    if (!selectedGodotExe) {
+        problems.push({
+            code: "MISSING_GODOT_EXECUTABLE",
+            message: "Godot executable was not found on PATH or configured locations.",
+            suggestedFix: "Download Godot 4 .NET edition and set GODOT_DOTNET_EXECUTABLE environment variable.",
+        });
+    }
+    else if (!godotHasDotnetSupport) {
+        problems.push({
+            code: "GODOT_MISSING_DOTNET_SUPPORT",
+            message: `Godot executable (${selectedGodotExe}) was found, but it does not include .NET/C# support.`,
+            suggestedFix: "Install or configure the Godot 4 .NET (Mono) edition.",
+        });
+    }
+    let projectTargetFrameworks = [];
+    if (input.projectPath) {
+        const workspace = registry.getWorkspace(input.workspaceId);
+        const targetDir = registry.resolvePath(workspace, input.projectPath);
+        try {
+            const { readdir, readFile } = await import("node:fs/promises");
+            const files = await readdir(targetDir);
+            const csproj = files.find((file) => file.endsWith(".csproj"));
+            if (csproj) {
+                const content = await readFile(join(targetDir, csproj), "utf8");
+                const tfm = content.match(/<TargetFrameworks?>(.*?)<\/TargetFrameworks?>/i);
+                if (tfm)
+                    projectTargetFrameworks = tfm[1].split(";").map((target) => target.trim());
+            }
+        }
+        catch { }
+    }
+    let status = "ready";
+    if (problems.some((problem) => problem.code === "MISSING_DOTNET_SDK" || problem.code === "MISSING_GODOT_EXECUTABLE")) {
+        status = "invalid";
+    }
+    else if (problems.length > 0) {
+        status = "incomplete";
+    }
+    return {
+        godotExecutable: selectedGodotExe,
+        godotVersion: selectedGodotVersion,
+        godotHasDotnetSupport,
+        dotnetExecutable: dotnetInfo.dotnetExecutable,
+        dotnetSdkVersions: dotnetInfo.dotnetSdkVersions,
+        selectedDotnetSdk: dotnetInfo.selectedDotnetSdk,
+        projectTargetFrameworks,
+        architecture: dotnetInfo.architecture,
+        exportTemplatesInstalled: true,
+        status,
+        problems,
+    };
+}