auvrynt 1.0.1

package/dist/godot-csharp-project.js

@@ -0,0 +1,157 @@
+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 (entry.name === ".godot" || entry.name === "bin" || entry.name === "obj" || entry.name === "node_modules" || entry.name === ".git") {
+                    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 = [];
+    let nullable = "enable";
+    let 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 m;
+            while ((m = pkgRegex.exec(xml)) !== null)
+                packageReferences.push(m[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 });
+        const output = stdout + "\n" + stderr;
+        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: output.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 });
+        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/godot-csharp-runner.js

@@ -0,0 +1,146 @@
+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 command = `${godotExe} ${args.join(" ")}`;
+    const result = processManager.startProcess({
+        workspaceId: input.workspaceId,
+        command,
+        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 command = `${godotExe} ${args.join(" ")}`;
+    const result = processManager.startProcess({
+        workspaceId: input.workspaceId,
+        command,
+        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;
+        // Detect C# exception
+        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;
+        }
+        // Stack frame line: at Namespace.Class.Method(Type arg) in C:\path\File.cs:line 45
+        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;
+        }
+        // Godot ERROR / WARNING / PRINT
+        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);
+    // Group repeated identical messages
+    const grouped = [];
+    for (const entry of entries) {
+        const prev = grouped[grouped.length - 1];
+        if (prev && prev.message === entry.message && prev.severity === entry.severity) {
+            prev.repeatCount = (prev.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((e) => severityFilter.has(e.severity))
+        : parsed;
+    return {
+        processId: input.processId,
+        entries: filtered,
+        totalEntries: filtered.length,
+    };
+}

package/dist/godot-csharp-semantic.js

@@ -0,0 +1,161 @@
+import { readdir, readFile } from "node:fs/promises";
+import { join, relative } from "node:path";
+// Regex-based lightweight C# semantic search (for use without Roslyn LSP)
+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 = [];
+    const lines = content.split(/\r?\n/);
+    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 m;
+    while ((m = classRegex.exec(content)) !== null) {
+        const isPartial = !!m[3];
+        const className = m[4];
+        const inheritance = (m[5] ?? "").split(",").map((s) => s.trim()).filter(Boolean);
+        const baseClass = inheritance[0] ?? undefined;
+        const lineNumber = content.slice(0, m.index).split("\n").length;
+        // Extract [Export] properties
+        const exportedProperties = extractExportedProperties(content, className);
+        const signals = extractCsharpSignals(content);
+        const lifecycleOverrides = extractLifecycleOverrides(content);
+        classes.push({
+            className,
+            filePath,
+            line: lineNumber,
+            baseClass,
+            isPartial,
+            implementedInterfaces: inheritance.slice(1),
+            namespace,
+            exportedProperties,
+            signals,
+            lifecycleOverrides,
+        });
+    }
+    return classes;
+}
+function extractExportedProperties(content, _className) {
+    const props = [];
+    const exportRegex = /\[Export(?:Group|Subgroup|Category)?\(?"?(.*?)"?\)?\]\s+(?:public\s+)([\w?<>[\]]+)\s+(\w+)/g;
+    let m;
+    while ((m = exportRegex.exec(content)) !== null) {
+        props.push({
+            propertyName: m[3],
+            inspectorDisplayName: m[3].replace(/([A-Z])/g, " $1").trim(),
+            type: m[2],
+            exportAttribute: m[0].split("]")[0] + "]",
+            isNullable: m[2].endsWith("?"),
+        });
+    }
+    return props;
+}
+function extractCsharpSignals(content) {
+    const signals = [];
+    const delegateRegex = /\[Signal\]\s+public\s+delegate\s+void\s+(\w+)\((.*?)\)/g;
+    let m;
+    while ((m = delegateRegex.exec(content)) !== null) {
+        const name = m[1].replace(/EventHandler$/, "");
+        const params = m[2] ? m[2].split(",").map((p) => p.trim()) : [];
+        signals.push({ name, parameters: params, declaration: m[0] });
+    }
+    return signals;
+}
+function extractLifecycleOverrides(content) {
+    const lifecycles = [
+        "_Ready", "_Process", "_PhysicsProcess", "_Input", "_UnhandledInput",
+        "_Draw", "_EnterTree", "_ExitTree", "_Notification",
+        "_GetConfigurationWarnings",
+    ];
+    return lifecycles.filter((lc) => new RegExp(`override.*void.*${lc}\\s*\\(`).test(content));
+}
+export async function getCsharpDiagnostics(registry, input) {
+    // Returns diagnostics by parsing .csproj build output
+    // Live diagnostics require a Roslyn LSP; this scans for known anti-patterns
+    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 content = await readFile(join(dir, entry.name), "utf8").catch(() => "");
+                const rel = relative(workspace.root, join(dir, entry.name)).replace(/\\/g, "/");
+                if (!content.includes("partial class") && content.includes("extends")) {
+                    warnings.push(`${rel}: 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 absPath = registry.resolvePath(workspace, input.scriptPath);
+    const content = await readFile(absPath, "utf8");
+    return extractExportedProperties(content, "");
+}
+export async function generateCsharpScript(params) {
+    const base = params.baseType ?? "Node";
+    const nsOpen = params.namespace ? `namespace ${params.namespace}\n{\n` : "";
+    const nsClose = params.namespace ? `}\n` : "";
+    const indent = params.namespace ? "    " : "";
+    return [
+        "using Godot;",
+        "",
+        nsOpen,
+        `${indent}public partial class ${params.className} : ${base}`,
+        `${indent}{`,
+        `${indent}    public override void _Ready()`,
+        `${indent}    {`,
+        `${indent}    }`,
+        `${indent}}`,
+        nsClose,
+    ]
+        .join("\n")
+        .trim() + "\n";
+}

package/dist/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 });
+        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 });
+        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),
+        };
+    }
+}