auvrynt 1.0.2 → 1.0.5

package/dist/godot-csharp-project.js

@@ -1,157 +1 @@
-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),
-        };
-    }
-}
+export * from "./integrations/godot/godot-csharp-project.js";

package/dist/godot-csharp-runner.js

@@ -1,146 +1 @@
-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,
-    };
-}
+export * from "./integrations/godot/godot-csharp-runner.js";

package/dist/godot-csharp-semantic.js

@@ -1,161 +1 @@
-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";
-}
+export * from "./integrations/godot/godot-csharp-semantic.js";

package/dist/godot-csharp-validate.js

@@ -1,71 +1 @@
-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),
-        };
-    }
-}
+export * from "./integrations/godot/godot-csharp-validate.js";