Refactor code structure for improved readability and maintainability; removed redundant code blocks and optimized function calls.

src/Scanner/__Libraries/StellaOps.Scanner.Analyzers.Lang.Deno/Internal/Runtime/DenoRuntimeTraceRunner.cs

@@ -0,0 +1,120 @@
+using System.Diagnostics;
+using Microsoft.Extensions.Logging;
+using StellaOps.Scanner.Analyzers.Lang;
+
+namespace StellaOps.Scanner.Analyzers.Lang.Deno.Internal.Runtime;
+
+/// <summary>
+/// Optional harness that executes the emitted Deno runtime shim when an entrypoint is provided via environment variable.
+/// This keeps runtime capture opt-in and offline-friendly.
+/// </summary>
+internal static class DenoRuntimeTraceRunner
+{
+    private const string EntrypointEnvVar = "STELLA_DENO_ENTRYPOINT";
+    private const string BinaryEnvVar = "STELLA_DENO_BINARY";
+    private const string RuntimeFileName = "deno-runtime.ndjson";
+
+    public static async Task<bool> TryExecuteAsync(
+        LanguageAnalyzerContext context,
+        ILogger? logger,
+        CancellationToken cancellationToken)
+    {
+        ArgumentNullException.ThrowIfNull(context);
+
+        var entrypoint = Environment.GetEnvironmentVariable(EntrypointEnvVar);
+        if (string.IsNullOrWhiteSpace(entrypoint))
+        {
+            logger?.LogDebug("Deno runtime trace skipped: {EnvVar} not set", EntrypointEnvVar);
+            return false;
+        }
+
+        var entrypointPath = Path.GetFullPath(Path.Combine(context.RootPath, entrypoint));
+        if (!File.Exists(entrypointPath))
+        {
+            logger?.LogWarning("Deno runtime trace skipped: entrypoint '{Entrypoint}' missing", entrypointPath);
+            return false;
+        }
+
+        var shimPath = Path.Combine(context.RootPath, DenoRuntimeShim.FileName);
+        if (!File.Exists(shimPath))
+        {
+            await DenoRuntimeShim.WriteAsync(context.RootPath, cancellationToken).ConfigureAwait(false);
+        }
+
+        var binary = Environment.GetEnvironmentVariable(BinaryEnvVar);
+        if (string.IsNullOrWhiteSpace(binary))
+        {
+            binary = "deno";
+        }
+
+        var startInfo = new ProcessStartInfo
+        {
+            FileName = binary,
+            WorkingDirectory = context.RootPath,
+            RedirectStandardError = true,
+            RedirectStandardOutput = true,
+            UseShellExecute = false,
+        };
+
+        startInfo.ArgumentList.Add("run");
+        startInfo.ArgumentList.Add("--cached-only");
+        startInfo.ArgumentList.Add("--allow-read");
+        startInfo.ArgumentList.Add("--allow-env");
+        startInfo.ArgumentList.Add("--quiet");
+        startInfo.ArgumentList.Add(shimPath);
+
+        startInfo.Environment[EntrypointEnvVar] = entrypointPath;
+
+        try
+        {
+            using var process = Process.Start(startInfo);
+            if (process is null)
+            {
+                logger?.LogWarning("Deno runtime trace skipped: failed to start 'deno' process");
+                return false;
+            }
+
+            await process.WaitForExitAsync(cancellationToken).ConfigureAwait(false);
+
+            if (process.ExitCode != 0)
+            {
+                var stderr = await process.StandardError.ReadToEndAsync().ConfigureAwait(false);
+                logger?.LogWarning(
+                    "Deno runtime trace failed with exit code {ExitCode}. stderr: {Error}",
+                    process.ExitCode,
+                    Truncate(stderr));
+                return false;
+            }
+        }
+        catch (OperationCanceledException)
+        {
+            throw;
+        }
+        catch (Exception ex)
+        {
+            logger?.LogWarning(ex, "Deno runtime trace skipped: {Message}", ex.Message);
+            return false;
+        }
+
+        var runtimePath = Path.Combine(context.RootPath, RuntimeFileName);
+        if (!File.Exists(runtimePath))
+        {
+            logger?.LogWarning(
+                "Deno runtime trace finished but did not emit {RuntimeFile}",
+                RuntimeFileName);
+            return false;
+        }
+
+        return true;
+    }
+
+    private static string Truncate(string? value, int maxLength = 400)
+    {
+        if (string.IsNullOrEmpty(value))
+        {
+            return string.Empty;
+        }
+
+        return value.Length <= maxLength ? value : value[..maxLength];
+    }
+}