auvrynt 1.0.1

package/dist/db/schema.js

@@ -0,0 +1,29 @@
+import { index, primaryKey, sqliteTable, text } from "drizzle-orm/sqlite-core";
+export const workspaceSessions = sqliteTable("workspace_sessions", {
+    id: text("id").primaryKey(),
+    root: text("root").notNull(),
+    status: text("status").notNull().default("active"),
+    mode: text("mode").notNull().default("checkout"),
+    sourceRoot: text("source_root"),
+    baseRef: text("base_ref"),
+    baseSha: text("base_sha"),
+    managed: text("managed").notNull().default("false"),
+    createdAt: text("created_at").notNull(),
+    lastUsedAt: text("last_used_at").notNull(),
+}, (table) => [
+    index("workspace_sessions_root_idx").on(table.root, table.lastUsedAt),
+    index("workspace_sessions_status_idx").on(table.status, table.lastUsedAt),
+]);
+export const loadedAgentFiles = sqliteTable("loaded_agent_files", {
+    workspaceSessionId: text("workspace_session_id")
+        .notNull()
+        .references(() => workspaceSessions.id, { onDelete: "cascade" }),
+    path: text("path").notNull(),
+    contentHash: text("content_hash").notNull(),
+    content: text("content").notNull(),
+    loadedAt: text("loaded_at").notNull(),
+    lastSeenAt: text("last_seen_at").notNull(),
+}, (table) => [
+    primaryKey({ columns: [table.workspaceSessionId, table.path] }),
+    index("loaded_agent_files_path_idx").on(table.path),
+]);

package/dist/dotnet-tools.js

@@ -0,0 +1,223 @@
+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/);
+    // Example MSBuild diagnostic line:
+    // C:\project\Program.cs(12,15): error CS1002: ; expected [C:\project\project.csproj]
+    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 = [];
+    // Summary line: Passed! - Failed: 1, Passed: 5, Skipped: 0, Total: 6
+    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 });
+        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 });
+        const fullOutput = stdout + "\n" + stderr;
+        const parsed = parseDotnetBuildOutput(fullOutput);
+        return {
+            success: parsed.success,
+            durationMs: Date.now() - start,
+            errors: parsed.errors,
+            warnings: parsed.warnings,
+        };
+    }
+    catch (err) {
+        const fullOutput = (err.stdout ?? "") + "\n" + (err.stderr ?? err.message);
+        const parsed = parseDotnetBuildOutput(fullOutput);
+        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 });
+        const parsed = parseDotnetTestOutput(stdout + "\n" + stderr);
+        return {
+            ...parsed,
+            durationMs: Date.now() - start,
+        };
+    }
+    catch (err) {
+        const parsed = parseDotnetTestOutput((err.stdout ?? "") + "\n" + (err.stderr ?? err.message));
+        return {
+            ...parsed,
+            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) });
+        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/git-worktrees.js

@@ -0,0 +1,134 @@
+import { randomBytes } from "node:crypto";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { mkdir, realpath, rm, stat } from "node:fs/promises";
+import { basename, join, relative, resolve } from "node:path";
+import { assertAllowedPath, isPathInsideRoot } from "./roots.js";
+const execFileAsync = promisify(execFile);
+export class GitWorktreeError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+        this.name = "GitWorktreeError";
+    }
+}
+export async function createManagedWorktree(input) {
+    const sourcePath = assertAllowedPath(input.sourcePath, input.config.allowedRoots);
+    try {
+        const sourceStats = await stat(sourcePath);
+        if (!sourceStats.isDirectory()) {
+            throw new GitWorktreeError("GIT_REPOSITORY_NOT_FOUND", `Cannot open workspace in worktree mode because the source path is not a directory: ${input.sourcePath}`);
+        }
+    }
+    catch (error) {
+        if (error instanceof GitWorktreeError)
+            throw error;
+        throw new GitWorktreeError("GIT_REPOSITORY_NOT_FOUND", `Cannot open workspace in worktree mode because the source path does not exist: ${input.sourcePath}`);
+    }
+    const sourceRoot = await resolveGitRoot(sourcePath, input.config.allowedRoots);
+    const baseRef = input.baseRef ?? "HEAD";
+    const baseSha = await resolveBaseCommit(sourceRoot, baseRef);
+    const dirtySource = (await git(["status", "--porcelain=v1"], sourceRoot)).trim().length > 0;
+    const worktreePath = managedWorktreePath({
+        worktreeRoot: input.config.worktreeRoot,
+        repoRoot: sourceRoot,
+    });
+    await mkdir(input.config.worktreeRoot, { recursive: true });
+    assertAllowedPath(worktreePath, [input.config.worktreeRoot]);
+    try {
+        await git(["worktree", "add", "--detach", worktreePath, baseSha], sourceRoot);
+    }
+    catch (error) {
+        await rm(worktreePath, { recursive: true, force: true });
+        const message = error instanceof Error ? error.message : String(error);
+        throw new GitWorktreeError("GIT_WORKTREE_CREATE_FAILED", `Git failed to create the managed worktree. ${message}`);
+    }
+    return {
+        sourceRoot,
+        path: worktreePath,
+        baseRef,
+        baseSha,
+        dirtySource,
+        detached: true,
+        managed: true,
+    };
+}
+async function resolveGitRoot(path, allowedRoots) {
+    try {
+        const output = await git(["rev-parse", "--show-toplevel"], path);
+        return await assertGitRootAllowed(output.trim(), allowedRoots);
+    }
+    catch (error) {
+        if (isGitUnavailable(error)) {
+            throw new GitWorktreeError("GIT_NOT_AVAILABLE", "Cannot open workspace in worktree mode because Git is not available on this machine.");
+        }
+        throw new GitWorktreeError("GIT_REPOSITORY_NOT_FOUND", `Cannot open workspace in worktree mode because this path is not inside a Git repository: ${path}. Use mode=\"checkout\" to work directly in this directory, or initialize Git and create an initial commit first.`);
+    }
+}
+async function assertGitRootAllowed(gitRoot, allowedRoots) {
+    try {
+        return assertAllowedPath(gitRoot, allowedRoots);
+    }
+    catch {
+        const canonicalGitRoot = await realpath(gitRoot);
+        for (const allowedRoot of allowedRoots) {
+            const canonicalAllowedRoot = await realpath(allowedRoot).catch(() => undefined);
+            if (!canonicalAllowedRoot || !isPathInsideRoot(canonicalGitRoot, canonicalAllowedRoot)) {
+                continue;
+            }
+            const logicalGitRoot = resolve(allowedRoot, relative(canonicalAllowedRoot, canonicalGitRoot));
+            return assertAllowedPath(logicalGitRoot, allowedRoots);
+        }
+        return assertAllowedPath(canonicalGitRoot, allowedRoots);
+    }
+}
+async function resolveBaseCommit(sourceRoot, baseRef) {
+    try {
+        return (await git(["rev-parse", "--verify", `${baseRef}^{commit}`], sourceRoot)).trim();
+    }
+    catch (error) {
+        if (baseRef === "HEAD") {
+            throw new GitWorktreeError("GIT_REPOSITORY_HAS_NO_COMMITS", "Cannot open workspace in worktree mode because the repository has no commits yet. Create an initial commit first, or use mode=\"checkout\".");
+        }
+        throw new GitWorktreeError("GIT_INVALID_BASE_REF", `Cannot open workspace in worktree mode because baseRef ${JSON.stringify(baseRef)} does not resolve to a commit.`);
+    }
+}
+function managedWorktreePath(input) {
+    const repoName = sanitizePathSegment(basename(input.repoRoot)) || "repo";
+    const worktreeId = randomBytes(4).toString("hex");
+    return join(input.worktreeRoot, `${repoName}-${worktreeId}`);
+}
+function sanitizePathSegment(value) {
+    return value
+        .replace(/[^a-zA-Z0-9._-]+/g, "-")
+        .replace(/^-+|-+$/g, "")
+        .slice(0, 80);
+}
+async function git(args, cwd) {
+    try {
+        const { stdout } = await execFileAsync("git", args, {
+            cwd,
+            maxBuffer: 10 * 1024 * 1024,
+        });
+        return stdout;
+    }
+    catch (error) {
+        if (isGitUnavailable(error))
+            throw error;
+        const stderr = typeof error === "object" && error && "stderr" in error
+            ? String(error.stderr ?? "").trim()
+            : "";
+        const stdout = typeof error === "object" && error && "stdout" in error
+            ? String(error.stdout ?? "").trim()
+            : "";
+        const details = stderr || stdout || (error instanceof Error ? error.message : String(error));
+        throw new Error(details);
+    }
+}
+function isGitUnavailable(error) {
+    return Boolean(typeof error === "object" &&
+        error &&
+        "code" in error &&
+        error.code === "ENOENT");
+}

package/dist/git.js

@@ -0,0 +1,41 @@
+import { createHash } from "node:crypto";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+const execFileAsync = promisify(execFile);
+export async function git(cwd, args, options = {}) {
+    const { stdout, stderr } = await execFileAsync("git", args, {
+        cwd,
+        env: options.env ? { ...process.env, ...options.env } : process.env,
+        maxBuffer: options.maxBuffer ?? 10 * 1024 * 1024,
+    });
+    return { stdout, stderr };
+}
+export async function getGitEligibility(cwd) {
+    try {
+        await git(cwd, ["rev-parse", "--is-inside-work-tree"]);
+    }
+    catch {
+        return {
+            ok: false,
+            reason: "not_git",
+            message: "workspace is not inside a git repository",
+        };
+    }
+    const gitRoot = (await git(cwd, ["rev-parse", "--show-toplevel"])).stdout.trim();
+    try {
+        await git(gitRoot, ["rev-parse", "--verify", "--quiet", "HEAD^{commit}"]);
+    }
+    catch {
+        return {
+            ok: false,
+            gitRoot,
+            reason: "no_head",
+            message: "repository has no HEAD commit",
+        };
+    }
+    return { ok: true, gitRoot };
+}
+export function safeWorkspaceRefSegment(workspaceId) {
+    const safe = workspaceId.replace(/[^A-Za-z0-9._-]/g, "-");
+    return safe.length > 0 ? safe : createHash("sha256").update(workspaceId).digest("hex").slice(0, 16);
+}

package/dist/godot-animation-tilemap.js

@@ -0,0 +1,82 @@
+// Bridge-based animation listing (requires live editor bridge)
+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.0,
+        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 anim = await getAnimation(input, bridgeClient);
+    const issues = [];
+    if (anim.lengthSeconds === 0)
+        issues.push("Animation length is zero.");
+    for (const track of anim.tracks) {
+        if (track.keys.length === 0)
+            issues.push(`Track '${track.targetPath}' has no keys.`);
+    }
+    return { valid: issues.length === 0, issues };
+}
+// ─── TileMap Tools ─────────────────────────────────────────────────────────
+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.");
+    const result = await bridgeClient.sendRequest("tilemap.validate", { nodePath: input.tileMapNodePath });
+    return result;
+}
+// ─── Physics Tools ─────────────────────────────────────────────────────────
+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.");
+    const result = await bridgeClient.sendRequest("physics.validate_collisions", { nodePath: input.nodePath ?? "/" });
+    return result;
+}
+// ─── Camera Tools ──────────────────────────────────────────────────────────
+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/godot-csharp-build.js

@@ -0,0 +1,93 @@
+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) });
+        const fullOutput = stdout + "\n" + stderr;
+        const parsed = parseGodotBuildDiagnostics(fullOutput);
+        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 fullOutput = (err.stdout ?? "") + "\n" + (err.stderr ?? err.message);
+        const parsed = parseGodotBuildDiagnostics(fullOutput);
+        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 });
+        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),
+        };
+    }
+}