my problem statement-> You are an AI assistant he...

Below is a ready-to-run Visual Studio / dotnet 9 console application that fulfils every point in your brief:

• reads one local log file
• sends it to your locally-running gemma3:4b model through the Ollama /api/generate endpoint
• collects the streamed (or non-streamed) response
• optionally parses out Test Issues and Product Issues for quick console viewing
• writes the entire AI analysis to a plain-text file on disk – no HTML, no JSON.

1. Create the project

powershell
# open a Developer PowerShell or the VS terminal
dotnet new console -n LogInsightTool
cd LogInsightTool

If you prefer the Visual Studio GUI: File → New → Project → Console App → Next → Framework “.NET 9.0” → Create, then paste Program.cs later.

2. Add one NuGet helper (optional but handy)

We’ll use System.CommandLine for nice CLI parsing; remove this line if you want to keep pure args[].

powershell
dotnet add package System.CommandLine --version 2.0.0-beta4.22272.1

3. Replace the generated Program.cs

csharp
using System.CommandLine;
using System.Net.Http;
using System.Text;
using System.Text.Json;
using System.Text.Json.Serialization;

// -------- CONFIG – tweak if you like --------
const string DefaultModel      = "gemma3";          // your local tag is gemma3:4b, but “gemma3” works as model name
const string DefaultLogPath    = @"local\BulkCreateEntity05_TextLog.txt";
const string DefaultOutputPath = @"analysis_output.txt";
const string OllamaUrl         = "http://localhost:11434/api/generate";
// --------------------------------------------

var root = new RootCommand("Nightly-test log insight utility (Ollama + gemma3:4b)")
{
    new Option<FileInfo>(
        name:   "--log",
        description: "Path to the test-execution log file",
        getDefaultValue: () => new FileInfo(DefaultLogPath)),

    new Option<FileInfo>(
        name:   "--out",
        description: "Where to save the plain-text AI analysis",
        getDefaultValue: () => new FileInfo(DefaultOutputPath)),

    new Option<string>(
        name:   "--model",
        description: "Ollama model name (local)",
        getDefaultValue: () => DefaultModel),

    new Option<bool>(
        name:   "--stream",
        description: "Use streaming mode (true = faster first token)",
        getDefaultValue: () => false)
};

root.SetHandler(async (FileInfo logFile, FileInfo outFile, string model, bool stream) =>
{
    if (!logFile.Exists)
    {
        Console.ForegroundColor = ConsoleColor.Red;
        Console.WriteLine($"ERROR: Log file not found: {logFile.FullName}");
        return;
    }

    Console.WriteLine($"➤ Reading log: {logFile.FullName}");
    var logContent = await File.ReadAllTextAsync(logFile.FullName);

    // ---------- Prompt identical to your PowerShell example ----------
    var prompt = $$"""
Analyze the provided test failure log to identify the reasons for failure and categorize them into product issues or test issues.

Test Case ID: [Insert Test Case ID]
Test Name: [Insert Test Name]
Test Description: [Insert Test Description]
Execution Category: [Insert Execution Category]
Test Machine: [Insert Test Machine Name]
Browser: [Insert Browser Name and Version]

Steps to Analyze:
Element Identification:
- Check for instances where elements were not found on the webpage.
- Verify the control methods used (e.g., xpath, Id) and the specific elements that were not found.

Action Failures:
- Identify any actions that failed, such as JavaClick actions.
- Determine if the failure was due to the element being NULL.

Exceptions:
- Look for any exceptions thrown during the test execution, such as StaleElementReferenceException or InvocationException.
- Analyze the stack trace to understand the context of the exceptions.

Segregation Criteria:
- Test Issue: Failures due to incorrect element locators, timing issues, or unstable elements in the test script.
- Product Issue: Failures due to malfunctioning or missing elements in the application itself.

Output:
Test Issues:
- List of failures attributed to test script problems (e.g., incorrect locators, timing issues).

Product Issues:
- List of failures attributed to application problems (e.g., missing elements, application errors).

==== BEGIN LOG ====
{{logContent}}
==== END LOG ====
""";
    // -----------------------------------------------------------------

    var payload = JsonSerializer.Serialize(new
    {
        model,
        prompt,
        stream
    });

    using var http = new HttpClient { Timeout = TimeSpan.FromMinutes(10) };
    using var res  = await http.PostAsync(OllamaUrl,
                    new StringContent(payload, Encoding.UTF8, "application/json"));

    res.EnsureSuccessStatusCode();

    Console.WriteLine("➤ Waiting for gemma3:4b to finish…");

    var sb = new StringBuilder();

    if (stream)
    {
        // Each line is a tiny JSON chunk: {"response":"text","done":false/true,...}
        await foreach (var line in ReadLinesAsync(await res.Content.ReadAsStreamAsync()))
        {
            if (string.IsNullOrWhiteSpace(line)) continue;
            var chunk = JsonSerializer.Deserialize<OllamaChunk>(line);
            if (!string.IsNullOrEmpty(chunk?.Response))
            {
                Console.Write(chunk.Response);   // live output
                sb.Append(chunk.Response);
            }
        }
        Console.WriteLine();
    }
    else
    {
        // Non-streamed: Ollama still returns multiple JSON lines
        var allText = await res.Content.ReadAsStringAsync();
        foreach (var line in allText.Split('\n'))
        {
            if (string.IsNullOrWhiteSpace(line)) continue;
            var chunk = JsonSerializer.Deserialize<OllamaChunk>(line);
            if (!string.IsNullOrEmpty(chunk?.Response))
                sb.Append(chunk.Response);
        }
    }

    var fullReply = sb.ToString();

    // --------- Quick extraction (optional) ---------
    var issues = ExtractSummary(fullReply);
    Console.ForegroundColor = ConsoleColor.Green;
    Console.WriteLine("\n===== QUICK SUMMARY =====");
    Console.ResetColor();
    Console.WriteLine($"• Test Issues   : {issues.TestIssues}");
    Console.WriteLine($"• Product Issues: {issues.ProductIssues}");
    Console.WriteLine("\n(See full analysis in output file.)");
    // -----------------------------------------------

    await File.WriteAllTextAsync(outFile.FullName, fullReply);
    Console.ForegroundColor = ConsoleColor.Cyan;
    Console.WriteLine($"\n➤ Analysis saved to {outFile.FullName}");
    Console.ResetColor();

}, root.Children.ToArray());

return await root.InvokeAsync(args);

// ------------ helpers ------------
static async IAsyncEnumerable<string> ReadLinesAsync(Stream stream)
{
    using var reader = new StreamReader(stream);
    while (!reader.EndOfStream)
        yield return await reader.ReadLineAsync() ?? "";
}

static (int TestIssues, int ProductIssues) ExtractSummary(string text)
{
    int Count(string header) =>
        text.Split('\n')
            .SkipWhile(l => !l.TrimStart().StartsWith(header, StringComparison.OrdinalIgnoreCase))
            .Skip(1)                        // jump past the header line
            .TakeWhile(l => !string.IsNullOrWhiteSpace(l))
            .Count(l => l.StartsWith("-")); // each bullet

    return (Count("Test Issues"), Count("Product Issues"));
}

record OllamaChunk([property: JsonPropertyName("response")] string Response);

What the code does – at a glance

4. Build & run

In Visual Studio

1. Paste the code into Program.cs.
2. Set Project → Properties → Debug → Application Arguments, e.g.:

--log "C:\Logs\BulkCreateEntity05_TextLog.txt" --out "C:\Logs\analysis_result.txt" --stream false

3. Hit Start (or Ctrl+F5).

In command line

powershell
dotnet run -- \
  --log "C:\Logs\BulkCreateEntity05_TextLog.txt" `
  --out "C:\Logs\analysis_result.txt" `
  --model "gemma3" `
  --stream false

(Back-ticks escape newlines in PowerShell; bash users omit them.)

5. What you should see

text
➤ Reading log: C:\Logs\BulkCreateEntity05_TextLog.txt
➤ Waiting for gemma3:4b to finish…
... AI tokens streaming here ...
===== QUICK SUMMARY =====
• Test Issues   : 17
• Product Issues: 2

➤ Analysis saved to C:\Logs\analysis_result.txt

Open analysis_result.txt – it contains the entire, human-readable diagnosis produced by gemma3:4b using your prompt.

6. Prerequisites checklist

That’s it — copy, build, run, and ship! 🎉

If you later expand to multiple nightly logs or Azure storage, plug the retrieval tier before the existing prompt section; the Ollama integration and file output stay exactly the same.