Generate and Execute C# Code

interface GenerateAndExecuteCSharpRequest {
  taskDescription: string;
}

interface GenerateAndExecuteCSharpResponse {
  success: boolean;
  result: string;
  message: string;
  timestamp: string;
}

/**
 * Generate and execute C# code based on a task description.
 * 
 * @param taskDescription - Natural language description of what the code should do
 * @param apiKey - Optional API key for authentication
 * @returns A promise that resolves to the execution results
 */
async function generateAndExecuteCSharp(
  taskDescription: string,
  apiKey?: string
): Promise {
  const url = 'http://localhost:5000/tools-api/code/csharp/generate-and-execute';
  
  const headers: Record = {
    'Content-Type': 'application/json'
  };
  
  // Add authorization header if API key is provided
  if (apiKey) {
    headers['Authorization'] = `Bearer ${apiKey}`;
  }
  
  const request: GenerateAndExecuteCSharpRequest = {
    taskDescription
  };
  
  const response = await fetch(url, {
    method: 'POST',
    headers,
    body: JSON.stringify(request)
  });
  
  return await response.json();
}

// Example usage
(async () => {
  const API_KEY = 'your_api_key_here';
  
  try {
    // Example 1: Take a screenshot and save it
    const taskDescription = `
    Take a screenshot of the current screen, save it to the desktop
    with the filename "screenshot_{current_date}.png" where {current_date}
    is in the format yyyy-MM-dd-HHmmss.
    Return the full path to the saved file.
    `;
    
    console.log('Generating and executing C# code for screenshot task...');
    const result = await generateAndExecuteCSharp(taskDescription, API_KEY);
    
    console.log(`Success: ${result.success}`);
    console.log(`Message: ${result.message}`);
    console.log(`Result: ${result.result}`);
    
    // Example 2: Get system information
    const sysInfoTask = `
    Gather the following system information:
    - Computer name
    - Windows version
    - CPU model and core count
    - Total RAM
    - Free disk space on all drives
    - Network adapters with their IP addresses
    
    Format the result as a JSON object.
    `;
    
    console.log('\nGenerating and executing C# code for system info task...');
    const sysInfoResult = await generateAndExecuteCSharp(sysInfoTask, API_KEY);
    
    console.log(`Success: ${sysInfoResult.success}`);
    if (sysInfoResult.success) {
      // Parse the JSON result to display it nicely
      const sysInfo = JSON.parse(sysInfoResult.result);
      console.log('System Information:');
      console.log(JSON.stringify(sysInfo, null, 2));
    } else {
      console.log(`Error: ${sysInfoResult.message}`);
    }
  } catch (error) {
    console.error('Error executing operation:', error);
  }
})();
                    

using System;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Text;
using System.Text.Json;
using System.Threading.Tasks;

public class GenerateAndExecuteCSharpRequest
{
    public string TaskDescription { get; set; }
}

public class GenerateAndExecuteCSharpResponse
{
    public bool Success { get; set; }
    public string Result { get; set; }
    public string Message { get; set; }
    public DateTime Timestamp { get; set; }
}

public class ToolsServerClient
{
    private readonly HttpClient _httpClient;
    private readonly string _apiKey;
    
    public ToolsServerClient(string apiKey = null)
    {
        _httpClient = new HttpClient();
        _httpClient.BaseAddress = new Uri("http://localhost:5000/");
        _apiKey = apiKey;
        
        if (!string.IsNullOrEmpty(apiKey))
        {
            _httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", apiKey);
        }
    }
    
    /// 

    /// Generate and execute C# code based on a task description.
    /// 
    /// Natural language description of what the code should do
    /// The execution results
    public async Task GenerateAndExecuteCSharpAsync(string taskDescription)
    {
        var request = new GenerateAndExecuteCSharpRequest
        {
            TaskDescription = taskDescription
        };
        
        var json = JsonSerializer.Serialize(request);
        var content = new StringContent(json, Encoding.UTF8, "application/json");
        
        var response = await _httpClient.PostAsync("tools-api/code/csharp/generate-and-execute", content);
        response.EnsureSuccessStatusCode();
        
        var responseBody = await response.Content.ReadAsStringAsync();
        return JsonSerializer.Deserialize(responseBody, new JsonSerializerOptions
        {
            PropertyNameCaseInsensitive = true
        });
    }
}

// Example usage
class Program
{
    static async Task Main(string[] args)
    {
        var client = new ToolsServerClient("your_api_key_here");
        
        try
        {
            // Example 1: Extract text from a PDF file
            var taskDescription = @"
                Open the PDF file at C:\Documents\report.pdf,
                extract all the text content,
                and return it as a string.
                If the file doesn't exist, return an appropriate error message.
            ";
            
            Console.WriteLine("Generating and executing C# code for PDF text extraction...");
            var result = await client.GenerateAndExecuteCSharpAsync(taskDescription);
            
            Console.WriteLine($"Success: {result.Success}");
            Console.WriteLine($"Message: {result.Message}");
            
            if (result.Success)
            {
                Console.WriteLine("First 100 characters of extracted text:");
                Console.WriteLine(result.Result.Length > 100 
                    ? result.Result.Substring(0, 100) + "..." 
                    : result.Result);
            }
            
            // Example 2: Monitor a process
            var monitorTaskDescription = @"
                Monitor the Chrome process for 10 seconds.
                Every second, record its CPU usage and memory consumption.
                Return a JSON array with the collected data points.
                If Chrome is not running, start it first.
            ";
            
            Console.WriteLine("\nGenerating and executing C# code for process monitoring...");
            var monitorResult = await client.GenerateAndExecuteCSharpAsync(monitorTaskDescription);
            
            Console.WriteLine($"Success: {monitorResult.Success}");
            if (monitorResult.Success)
            {
                Console.WriteLine("Monitoring result:");
                Console.WriteLine(monitorResult.Result);
            }
            else
            {
                Console.WriteLine($"Error: {monitorResult.Message}");
            }
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Error: {ex.Message}");
        }
    }
}