diff --git a/catalog/Frameworks/ThreeJS-WebGPU-TSL/skills/webgpu-threejs-tsl/manifest.json b/catalog/Frameworks/ThreeJS-WebGPU-TSL/skills/webgpu-threejs-tsl/manifest.json index 3ac2525..7070462 100644 --- a/catalog/Frameworks/ThreeJS-WebGPU-TSL/skills/webgpu-threejs-tsl/manifest.json +++ b/catalog/Frameworks/ThreeJS-WebGPU-TSL/skills/webgpu-threejs-tsl/manifest.json @@ -2,8 +2,8 @@ "version": "1.0.0", "category": "Web", "compatibility": "Requires a JavaScript or TypeScript project using Three.js WebGPU and TSL.", - "package_ecosystem": "npm", "packages": [ "three" - ] + ], + "package_ecosystem": "npm" } diff --git a/catalog/Platform/Official-DotNet-Dotnet11/skills/process-api-net11/SKILL.md b/catalog/Platform/Official-DotNet-Dotnet11/skills/process-api-net11/SKILL.md new file mode 100644 index 0000000..954a570 --- /dev/null +++ b/catalog/Platform/Official-DotNet-Dotnet11/skills/process-api-net11/SKILL.md @@ -0,0 +1,243 @@ +--- +name: process-api-net11 +description: > + Provides guidance on the new System.Diagnostics.Process APIs introduced in .NET 11: + Process.Run, Process.RunAndCaptureText, Process.StartAndForget, Process.ReadAllText/Bytes/Lines, + KillOnParentExit, InheritedHandles, and StartDetached. + USE FOR: starting, orchestrating, or capturing output from external processes in applications targeting net11.0 or later. + DO NOT USE FOR: applications targeting .NET 10 or earlier, or basic pre-.NET 11 Process.Start usage without new APIs. +license: MIT +--- + +# Process API Improvements — .NET 11 + +New APIs added to `System.Diagnostics.Process` in .NET 11 simplify process management, eliminate boilerplate, and prevent common deadlock patterns when capturing output in .NET 11 or later applications. + +## When to Use + +- Running or orchestrating external processes in a .NET 11 (or later) project. +- Needing to start a process, wait for it to exit, and capture its output/error streams without risking deadlocks (`Process.RunAndCaptureText[Async]`). +- Wanting to ensure child processes are automatically terminated when the parent process exits (`KillOnParentExit`). +- Requiring lightweight, low-overhead process creation via `SafeProcessHandle` on supported platforms. +- Requiring fine-grained control over handle inheritance (`InheritedHandles`) or starting detached processes (`StartDetached`). + +## When Not to Use + +- The project targets .NET 10 or earlier — these APIs are not available before .NET 11. +- The default `Process.Start()` is sufficient and does not require output capturing or advanced lifecycle rules. + +## Target Framework + +```xml +net11.0 +``` + +## New APIs + +### Types + +Before using the new convenience methods, note the following types. Use the framework types directly: + +| Type | Kind | Read-only properties | +|------|------|----------------------| +| `ProcessExitStatus` | Sealed class | `int ExitCode`, `bool Canceled`, `PosixSignal? Signal` | +| `ProcessTextOutput` | Sealed class | `ProcessExitStatus ExitStatus`, `string StandardOutput`, `string StandardError`, `int ProcessId` | +| `ProcessOutputLine` | Readonly struct | `string Content`, `bool StandardError` | + +`ProcessExitStatus` describes the outcome of a completed process. Interpret `ExitCode` using the external command's contract; there is no universal `Success` property. `ProcessTextOutput` contains the exit status, captured output and error text, and process ID. `ProcessOutputLine` identifies one output line and whether it came from standard error. + +### High-Level Convenience APIs + +#### Static Methods + +The `ProcessStartInfo` overloads below require `UseShellExecute = false`, which is the default for .NET. + +##### `Process.Run` / `Process.RunAsync` +Starts a process and waits for it to exit, returning the exit status. Does not capture standard output or error. Passing `silent: true` discards standard output and error by internally redirecting standard handles to the `NUL` device. On timeout or cancellation, the process is killed. +```csharp +public static ProcessExitStatus Run(string fileName, IEnumerable? arguments = null, bool silent = false, TimeSpan? timeout = null) +public static Task RunAsync(string fileName, IEnumerable? arguments = null, bool silent = false, CancellationToken cancellationToken = default) +public static ProcessExitStatus Run(ProcessStartInfo startInfo, TimeSpan? timeout = null) +public static Task RunAsync(ProcessStartInfo startInfo, CancellationToken cancellationToken = default) +``` + +##### `Process.RunAndCaptureText` / `Process.RunAndCaptureTextAsync` +Starts a process, captures both standard output and error, and waits for it to exit. Extremely useful for avoiding deadlocks on stream redirection. On timeout or cancellation, the process is killed. + +When using the `ProcessStartInfo` overloads, the caller is responsible for setting `RedirectStandardOutput = true` and `RedirectStandardError = true` on `ProcessStartInfo` (because BCL APIs cannot modify the input arguments they were given). +```csharp +public static ProcessTextOutput RunAndCaptureText(string fileName, IEnumerable? arguments = null, TimeSpan? timeout = null) +public static Task RunAndCaptureTextAsync(string fileName, IEnumerable? arguments = null, CancellationToken cancellationToken = default) +public static ProcessTextOutput RunAndCaptureText(ProcessStartInfo startInfo, TimeSpan? timeout = null) +public static Task RunAndCaptureTextAsync(ProcessStartInfo startInfo, CancellationToken cancellationToken = default) +``` + +##### `Process.StartAndForget` +There is a common misconception that when a process is disposed, it's also being killed. This is not the case, as `Process.Dispose` only releases the resources associated with the process, but does not kill it. + +To make it easier to start a process without the need to worry about disposing it, `Process.StartAndForget` was introduced. The method starts an executable, returns its ID, and immediately releases all handle resources associated with it. Standard handles not supplied through `StandardInputHandle`, `StandardOutputHandle`, or `StandardErrorHandle` go to the null device by default. + +`StartAndForget` throws `InvalidOperationException` if `UseShellExecute` or any `RedirectStandardInput`, `RedirectStandardOutput`, or `RedirectStandardError` flag is true. Use a capture or streaming API if output needs to be read. +```csharp +public static int StartAndForget(string fileName, IEnumerable? arguments = null) +public static int StartAndForget(ProcessStartInfo startInfo) +``` + +#### Instance Methods +These methods are called on a `Process` instance to directly read stdout and stderr, guaranteeing no OS pipe buffer overflow deadlocks. + +*Note: Calling these methods requires `RedirectStandardOutput = true` and `RedirectStandardError = true` on the `ProcessStartInfo` passed to `Process.Start`.* + +```csharp +public (string StandardOutput, string StandardError) ReadAllText(TimeSpan? timeout = null) +public Task<(string StandardOutput, string StandardError)> ReadAllTextAsync(CancellationToken cancellationToken = default) +public (byte[] StandardOutput, byte[] StandardError) ReadAllBytes(TimeSpan? timeout = null) +public Task<(byte[] StandardOutput, byte[] StandardError)> ReadAllBytesAsync(CancellationToken cancellationToken = default) +public IEnumerable ReadAllLines(TimeSpan? timeout = null) +public IAsyncEnumerable ReadAllLinesAsync(CancellationToken cancellationToken = default) +``` + +Example of deconstructing the tuple return: +```csharp +var (stdout, stderr) = await process.ReadAllTextAsync(); +``` + +### ProcessStartInfo Properties + +#### `KillOnParentExit` +Ensures that the spawned child process is terminated when the current (parent) process exits (including fatal crash and being force killed). Works across Windows, Linux, and Android. +```csharp +public bool KillOnParentExit { get; set; } +``` + +In cross-platform code, guard the property assignment with a supported-platform check, not only the assigned value. If automatic teardown is required, fail explicitly on an unsupported platform instead of starting an unprotected child process. +`KillOnParentExit` requires `UseShellExecute = false`. + +#### `InheritedHandles` +Provides precise control over which handles (file descriptors) are inherited by the child process, preventing accidental resource leaks. +- Standard handles (`stdin`, `stdout`, `stderr`) are always included (no need to add them to the list). +- Setting the list to an empty list means only standard handles get inherited. +- Only `SafeFileHandle` and `SafePipeHandle` instances are allowed as of today. +- No global lock is used when spawning new processes on Windows (important for tuning projects that spawn multiple processes in parallel). +- Concurrent process starts must not pass the same handle in `InheritedHandles`: the runtime temporarily changes its inheritance flags. Serialize starts that share a handle, or use separate handles for each concurrent start. +- Do not enable inheritance on the handles before passing them; other process-start APIs could then inherit them unintentionally. +- On Unix systems without native handle-inheritance control, setting this property can severely reduce process-start performance. +- A non-null list requires `UseShellExecute = false` and cannot be combined with a non-empty `UserName`. +```csharp +public IList? InheritedHandles { get; set; } +``` + +#### `StartDetached` +Starts the process detached from the parent's terminal or job session, ensuring it survives the parent's exit. +```csharp +public bool StartDetached { get; set; } +``` + +`StartDetached` requires `UseShellExecute = false`. + +--- + +## Examples + +### 1. One-Line Run and Capture Output + +Run a process and safely read all output text without stream deadlock risks. For simple CLI operations that don't need cancellation or async scalability, prefer the synchronous overload: + +```csharp +using System; +using System.Diagnostics; + +// Run 'git status' and capture output +ProcessTextOutput result = Process.RunAndCaptureText("git", ["status"]); + +if (result.ExitStatus.ExitCode == 0) +{ + Console.WriteLine($"Git Output: {result.StandardOutput}"); +} +else +{ + Console.WriteLine($"Failed with exit code: {result.ExitStatus.ExitCode}"); + Console.WriteLine($"Error: {result.StandardError}"); +} +``` + +### 2. Auto-Killing Child Processes on Parent Exit + +On Windows, Linux, and Android, ensure a long-running background worker process is killed when the main application terminates. On other platforms, this example stops before starting the child process: + +```csharp +using System; +using System.Diagnostics; + +ProcessStartInfo startInfo = new("dotnet", ["run", "--project", "BackgroundWorker.csproj"]); + +if (OperatingSystem.IsWindows() || OperatingSystem.IsLinux() || OperatingSystem.IsAndroid()) +{ + startInfo.KillOnParentExit = true; +} +else +{ + throw new PlatformNotSupportedException("This example requires Windows, Linux, or Android."); +} + +using Process process = Process.Start(startInfo)!; +// The background worker is now tied to this process's lifecycle +``` + +### 3. Read All Lines From Output + +Start a process and read its output lines safely: + +```csharp +using System; +using System.Diagnostics; +using System.Threading.Tasks; + +ProcessStartInfo startInfo = new("ping", ["127.0.0.1"]) +{ + RedirectStandardOutput = true, + RedirectStandardError = true +}; + +using Process process = Process.Start(startInfo)!; +// Read all output lines safely and asynchronously +await foreach (ProcessOutputLine line in process.ReadAllLinesAsync()) +{ + string prefix = line.StandardError ? "[Err]" : "[Out]"; + Console.WriteLine($"{prefix} > {line.Content}"); +} +``` + +### 4. Read Entire Output Deadlock-Free (Tuple Return) + +Start a process with custom `ProcessStartInfo` and read both stdout and stderr into a deconstructed tuple without buffer deadlocks: + +```csharp +using System; +using System.Diagnostics; +using System.Threading.Tasks; + +ProcessStartInfo startInfo = new("git", ["diff"]) +{ + RedirectStandardOutput = true, + RedirectStandardError = true +}; + +using Process process = Process.Start(startInfo)!; +var (stdout, stderr) = await process.ReadAllTextAsync(); + +Console.WriteLine($"Diff output: {stdout}"); +``` + +### 5. Start and Forget (Fire & Forget) + +Launch a helper executable without holding onto system handle structures: + +```csharp +using System; +using System.Diagnostics; + +// Fire and forget, getting back only the process ID +int pid = Process.StartAndForget("notepad.exe"); +Console.WriteLine($"Notepad started with PID: {pid}"); +``` diff --git a/catalog/Platform/Official-DotNet-Dotnet11/skills/process-api-net11/manifest.json b/catalog/Platform/Official-DotNet-Dotnet11/skills/process-api-net11/manifest.json new file mode 100644 index 0000000..1624632 --- /dev/null +++ b/catalog/Platform/Official-DotNet-Dotnet11/skills/process-api-net11/manifest.json @@ -0,0 +1,5 @@ +{ + "version": "0.1.2", + "category": "Core", + "compatibility": "Requires a .NET repository or solution." +} diff --git a/external-sources/upstreams/dotnet-skills/plugins/dotnet11/README.md b/external-sources/upstreams/dotnet-skills/plugins/dotnet11/README.md index 7a85a71..b706f17 100644 --- a/external-sources/upstreams/dotnet-skills/plugins/dotnet11/README.md +++ b/external-sources/upstreams/dotnet-skills/plugins/dotnet11/README.md @@ -4,4 +4,5 @@ Skills focused on new APIs and language features introduced in .NET 11. ## Skills +- process-api-net11 - system-text-json-net11 diff --git a/external-sources/upstreams/dotnet-skills/plugins/dotnet11/skills/process-api-net11/SKILL.md b/external-sources/upstreams/dotnet-skills/plugins/dotnet11/skills/process-api-net11/SKILL.md new file mode 100644 index 0000000..954a570 --- /dev/null +++ b/external-sources/upstreams/dotnet-skills/plugins/dotnet11/skills/process-api-net11/SKILL.md @@ -0,0 +1,243 @@ +--- +name: process-api-net11 +description: > + Provides guidance on the new System.Diagnostics.Process APIs introduced in .NET 11: + Process.Run, Process.RunAndCaptureText, Process.StartAndForget, Process.ReadAllText/Bytes/Lines, + KillOnParentExit, InheritedHandles, and StartDetached. + USE FOR: starting, orchestrating, or capturing output from external processes in applications targeting net11.0 or later. + DO NOT USE FOR: applications targeting .NET 10 or earlier, or basic pre-.NET 11 Process.Start usage without new APIs. +license: MIT +--- + +# Process API Improvements — .NET 11 + +New APIs added to `System.Diagnostics.Process` in .NET 11 simplify process management, eliminate boilerplate, and prevent common deadlock patterns when capturing output in .NET 11 or later applications. + +## When to Use + +- Running or orchestrating external processes in a .NET 11 (or later) project. +- Needing to start a process, wait for it to exit, and capture its output/error streams without risking deadlocks (`Process.RunAndCaptureText[Async]`). +- Wanting to ensure child processes are automatically terminated when the parent process exits (`KillOnParentExit`). +- Requiring lightweight, low-overhead process creation via `SafeProcessHandle` on supported platforms. +- Requiring fine-grained control over handle inheritance (`InheritedHandles`) or starting detached processes (`StartDetached`). + +## When Not to Use + +- The project targets .NET 10 or earlier — these APIs are not available before .NET 11. +- The default `Process.Start()` is sufficient and does not require output capturing or advanced lifecycle rules. + +## Target Framework + +```xml +net11.0 +``` + +## New APIs + +### Types + +Before using the new convenience methods, note the following types. Use the framework types directly: + +| Type | Kind | Read-only properties | +|------|------|----------------------| +| `ProcessExitStatus` | Sealed class | `int ExitCode`, `bool Canceled`, `PosixSignal? Signal` | +| `ProcessTextOutput` | Sealed class | `ProcessExitStatus ExitStatus`, `string StandardOutput`, `string StandardError`, `int ProcessId` | +| `ProcessOutputLine` | Readonly struct | `string Content`, `bool StandardError` | + +`ProcessExitStatus` describes the outcome of a completed process. Interpret `ExitCode` using the external command's contract; there is no universal `Success` property. `ProcessTextOutput` contains the exit status, captured output and error text, and process ID. `ProcessOutputLine` identifies one output line and whether it came from standard error. + +### High-Level Convenience APIs + +#### Static Methods + +The `ProcessStartInfo` overloads below require `UseShellExecute = false`, which is the default for .NET. + +##### `Process.Run` / `Process.RunAsync` +Starts a process and waits for it to exit, returning the exit status. Does not capture standard output or error. Passing `silent: true` discards standard output and error by internally redirecting standard handles to the `NUL` device. On timeout or cancellation, the process is killed. +```csharp +public static ProcessExitStatus Run(string fileName, IEnumerable? arguments = null, bool silent = false, TimeSpan? timeout = null) +public static Task RunAsync(string fileName, IEnumerable? arguments = null, bool silent = false, CancellationToken cancellationToken = default) +public static ProcessExitStatus Run(ProcessStartInfo startInfo, TimeSpan? timeout = null) +public static Task RunAsync(ProcessStartInfo startInfo, CancellationToken cancellationToken = default) +``` + +##### `Process.RunAndCaptureText` / `Process.RunAndCaptureTextAsync` +Starts a process, captures both standard output and error, and waits for it to exit. Extremely useful for avoiding deadlocks on stream redirection. On timeout or cancellation, the process is killed. + +When using the `ProcessStartInfo` overloads, the caller is responsible for setting `RedirectStandardOutput = true` and `RedirectStandardError = true` on `ProcessStartInfo` (because BCL APIs cannot modify the input arguments they were given). +```csharp +public static ProcessTextOutput RunAndCaptureText(string fileName, IEnumerable? arguments = null, TimeSpan? timeout = null) +public static Task RunAndCaptureTextAsync(string fileName, IEnumerable? arguments = null, CancellationToken cancellationToken = default) +public static ProcessTextOutput RunAndCaptureText(ProcessStartInfo startInfo, TimeSpan? timeout = null) +public static Task RunAndCaptureTextAsync(ProcessStartInfo startInfo, CancellationToken cancellationToken = default) +``` + +##### `Process.StartAndForget` +There is a common misconception that when a process is disposed, it's also being killed. This is not the case, as `Process.Dispose` only releases the resources associated with the process, but does not kill it. + +To make it easier to start a process without the need to worry about disposing it, `Process.StartAndForget` was introduced. The method starts an executable, returns its ID, and immediately releases all handle resources associated with it. Standard handles not supplied through `StandardInputHandle`, `StandardOutputHandle`, or `StandardErrorHandle` go to the null device by default. + +`StartAndForget` throws `InvalidOperationException` if `UseShellExecute` or any `RedirectStandardInput`, `RedirectStandardOutput`, or `RedirectStandardError` flag is true. Use a capture or streaming API if output needs to be read. +```csharp +public static int StartAndForget(string fileName, IEnumerable? arguments = null) +public static int StartAndForget(ProcessStartInfo startInfo) +``` + +#### Instance Methods +These methods are called on a `Process` instance to directly read stdout and stderr, guaranteeing no OS pipe buffer overflow deadlocks. + +*Note: Calling these methods requires `RedirectStandardOutput = true` and `RedirectStandardError = true` on the `ProcessStartInfo` passed to `Process.Start`.* + +```csharp +public (string StandardOutput, string StandardError) ReadAllText(TimeSpan? timeout = null) +public Task<(string StandardOutput, string StandardError)> ReadAllTextAsync(CancellationToken cancellationToken = default) +public (byte[] StandardOutput, byte[] StandardError) ReadAllBytes(TimeSpan? timeout = null) +public Task<(byte[] StandardOutput, byte[] StandardError)> ReadAllBytesAsync(CancellationToken cancellationToken = default) +public IEnumerable ReadAllLines(TimeSpan? timeout = null) +public IAsyncEnumerable ReadAllLinesAsync(CancellationToken cancellationToken = default) +``` + +Example of deconstructing the tuple return: +```csharp +var (stdout, stderr) = await process.ReadAllTextAsync(); +``` + +### ProcessStartInfo Properties + +#### `KillOnParentExit` +Ensures that the spawned child process is terminated when the current (parent) process exits (including fatal crash and being force killed). Works across Windows, Linux, and Android. +```csharp +public bool KillOnParentExit { get; set; } +``` + +In cross-platform code, guard the property assignment with a supported-platform check, not only the assigned value. If automatic teardown is required, fail explicitly on an unsupported platform instead of starting an unprotected child process. +`KillOnParentExit` requires `UseShellExecute = false`. + +#### `InheritedHandles` +Provides precise control over which handles (file descriptors) are inherited by the child process, preventing accidental resource leaks. +- Standard handles (`stdin`, `stdout`, `stderr`) are always included (no need to add them to the list). +- Setting the list to an empty list means only standard handles get inherited. +- Only `SafeFileHandle` and `SafePipeHandle` instances are allowed as of today. +- No global lock is used when spawning new processes on Windows (important for tuning projects that spawn multiple processes in parallel). +- Concurrent process starts must not pass the same handle in `InheritedHandles`: the runtime temporarily changes its inheritance flags. Serialize starts that share a handle, or use separate handles for each concurrent start. +- Do not enable inheritance on the handles before passing them; other process-start APIs could then inherit them unintentionally. +- On Unix systems without native handle-inheritance control, setting this property can severely reduce process-start performance. +- A non-null list requires `UseShellExecute = false` and cannot be combined with a non-empty `UserName`. +```csharp +public IList? InheritedHandles { get; set; } +``` + +#### `StartDetached` +Starts the process detached from the parent's terminal or job session, ensuring it survives the parent's exit. +```csharp +public bool StartDetached { get; set; } +``` + +`StartDetached` requires `UseShellExecute = false`. + +--- + +## Examples + +### 1. One-Line Run and Capture Output + +Run a process and safely read all output text without stream deadlock risks. For simple CLI operations that don't need cancellation or async scalability, prefer the synchronous overload: + +```csharp +using System; +using System.Diagnostics; + +// Run 'git status' and capture output +ProcessTextOutput result = Process.RunAndCaptureText("git", ["status"]); + +if (result.ExitStatus.ExitCode == 0) +{ + Console.WriteLine($"Git Output: {result.StandardOutput}"); +} +else +{ + Console.WriteLine($"Failed with exit code: {result.ExitStatus.ExitCode}"); + Console.WriteLine($"Error: {result.StandardError}"); +} +``` + +### 2. Auto-Killing Child Processes on Parent Exit + +On Windows, Linux, and Android, ensure a long-running background worker process is killed when the main application terminates. On other platforms, this example stops before starting the child process: + +```csharp +using System; +using System.Diagnostics; + +ProcessStartInfo startInfo = new("dotnet", ["run", "--project", "BackgroundWorker.csproj"]); + +if (OperatingSystem.IsWindows() || OperatingSystem.IsLinux() || OperatingSystem.IsAndroid()) +{ + startInfo.KillOnParentExit = true; +} +else +{ + throw new PlatformNotSupportedException("This example requires Windows, Linux, or Android."); +} + +using Process process = Process.Start(startInfo)!; +// The background worker is now tied to this process's lifecycle +``` + +### 3. Read All Lines From Output + +Start a process and read its output lines safely: + +```csharp +using System; +using System.Diagnostics; +using System.Threading.Tasks; + +ProcessStartInfo startInfo = new("ping", ["127.0.0.1"]) +{ + RedirectStandardOutput = true, + RedirectStandardError = true +}; + +using Process process = Process.Start(startInfo)!; +// Read all output lines safely and asynchronously +await foreach (ProcessOutputLine line in process.ReadAllLinesAsync()) +{ + string prefix = line.StandardError ? "[Err]" : "[Out]"; + Console.WriteLine($"{prefix} > {line.Content}"); +} +``` + +### 4. Read Entire Output Deadlock-Free (Tuple Return) + +Start a process with custom `ProcessStartInfo` and read both stdout and stderr into a deconstructed tuple without buffer deadlocks: + +```csharp +using System; +using System.Diagnostics; +using System.Threading.Tasks; + +ProcessStartInfo startInfo = new("git", ["diff"]) +{ + RedirectStandardOutput = true, + RedirectStandardError = true +}; + +using Process process = Process.Start(startInfo)!; +var (stdout, stderr) = await process.ReadAllTextAsync(); + +Console.WriteLine($"Diff output: {stdout}"); +``` + +### 5. Start and Forget (Fire & Forget) + +Launch a helper executable without holding onto system handle structures: + +```csharp +using System; +using System.Diagnostics; + +// Fire and forget, getting back only the process ID +int pid = Process.StartAndForget("notepad.exe"); +Console.WriteLine($"Notepad started with PID: {pid}"); +``` diff --git a/external-sources/upstreams/roslynk/README.md b/external-sources/upstreams/roslynk/README.md index f4e9d7f..becee66 100644 --- a/external-sources/upstreams/roslynk/README.md +++ b/external-sources/upstreams/roslynk/README.md @@ -2,10 +2,6 @@ **Roslyn + link** — the link between AI test harnesses and Roslyn. -> [![YourKit](https://www.yourkit.com/images/yklogo.png)](https://www.yourkit.com/) -> -> Roslynk is an open-source project using [YourKit .NET Profiler](https://www.yourkit.com/dotnet-profiler/). - Add the MCP to your AI harness, then type "Open (solution file name)" - that's it! The biggest time saver you will see is checking for compiler errors and warnings; with diff --git a/external-sources/vendir.lock.yml b/external-sources/vendir.lock.yml index c6cc2e7..3118b4f 100644 --- a/external-sources/vendir.lock.yml +++ b/external-sources/vendir.lock.yml @@ -2,10 +2,10 @@ apiVersion: vendir.k14s.io/v1alpha1 directories: - contents: - git: - commitTitle: 'Merge pull request #1290 from dotnet/abhitejjohn-dotnet11-code-owner...' - sha: 1d40f95ed0f2cdedfa4c9b2614b7c2035a4323cb + commitTitle: 'Merge pull request #1284 from dotnet/abhitejjohn-skill-eval-follow-up...' + sha: 19bb55d785cd88ce47a1b43f9a21d0192c412dac tags: - - skill-validator-nightly + - skill-validator-nightly-24-g19bb55d7 path: dotnet-skills - git: commitTitle: Add Cursor rules that reference the existing skill docs... @@ -19,10 +19,10 @@ directories: - '@astrojs/markdoc@2.0.11-12-g9050e3819c' path: astro - git: - commitTitle: Fix flakey test - sha: 71a8d132dde2a820ad05cc25a2368a7985317d69 + commitTitle: Remove YourKit credit + sha: 474cac03c49edfa5d0171c16746b9283621d2886 tags: - - 2.1.0-16-g71a8d13 + - 2.1.0-17-g474cac0 path: roslynk path: upstreams kind: LockConfig