Mykeels.CSharpRepl 0.0.8

Mykeels.CSharpRepl

This library is a stripped-down, plug-n-play version of CSharpRepl.Services. It is a powerful C# REPL (Read-Eval-Print Loop) that can be embedded into any .NET application, providing an interactive C# REPL environment with syntax highlighting, code completion, MCP server, and more.

Installation

dotnet add package Mykeels.CSharpRepl

Quick Start

Here's a minimal example of how to use Mykeels.CSharpRepl in your application to launch a REPL:

using Mykeels.CSharpRepl;

await Repl.Run();

This will start an interactive C# REPL with default settings.

Configuration

You can customize the REPL by providing a Configuration object:

using CSharpRepl.Services;
using Mykeels.CSharpRepl;
using Spectre.Console;

await Repl.Run(
    new Configuration(
        // Add references to assemblies
        references: AppDomain
            .CurrentDomain.GetAssemblies()
            .Select(a => $"{a.GetName().Name}.dll")
            .ToArray(),
        
        // Add default namespaces
        usings: [
            "System",
            "System.Collections.Generic",
            "System.IO",
            "System.Linq",
            "System.Net.Http",
            "System.Threading",
            "System.Threading.Tasks"
        ],
        
        // Set application name
        applicationName: "MyApp.CSharpRepl",
        
        // Customize success output
        logSuccess: (message, result) => {
            Console.WriteLine($"<< {message}");
            string output = Newtonsoft.Json.JsonConvert.SerializeObject(result);
            AnsiConsole.MarkupLine($"[green]>> {output}[/]");
        },
        
        // Customize error output
        logError: (message, exception, _) => {
            Console.WriteLine($"<< {message}");
            string output = Newtonsoft.Json.JsonConvert.SerializeObject(
                new { Error = exception }
            );
            Console.WriteLine($">> {output}");
            AnsiConsole.MarkupLine($"[red]>> {output.EscapeMarkup()}[/]");
        }
    )
);

Pre-execution Commands

You can specify commands to be executed before the REPL starts. This is useful for setting up the environment or importing commonly used types:

await Repl.Run(
    commands: [
        // Import ScriptGlobals to make its methods available directly
        "using static Mykeels.CSharpRepl.Sample.ScriptGlobals;"
    ]
);

ScriptGlobals

You can add your own ScriptGlobals by adding a static class with static methods and properties, and then running a pre-execution command on REPL startup.

"using static Mykeels.CSharpRepl.Sample.ScriptGlobals;"

MCP Server

You can also launch a MCP server that can be used to:

• list members of the ScriptGlobals class
• invoke arbitrary C# code, written with the ScriptGlobals class as the globals context

await McpServer.Run(typeof(ScriptGlobals));

Such an MCP server can be used by a tool like Cursor to give Cursor Chat the ability to execute C# code.

Features

• Syntax Highlighting: Code is colorized for better readability
• Code Completion: Intelligent code completion with IntelliSense
• Error Handling: Detailed error messages with stack traces
• JSON Output: Results are automatically serialized to JSON
• Customizable: Configure references, namespaces, and output formatting
• Interactive: Full C# interactive environment with REPL capabilities

Configuration Options

The Configuration class supports the following options:

• references: Array of assembly references to load
• usings: Array of namespaces to import by default
• applicationName: Name of your application
• logSuccess: Callback for handling successful evaluations
• logError: Callback for handling evaluation errors
• commands: Array of commands to execute before starting the REPL

Examples

Basic Usage

await Repl.Run();

With Custom References

await Repl.Run(
    new Configuration(
        references: ["MyApp.dll", "MyApp.Models.dll"]
    )
);

With Custom Output Formatting

await Repl.Run(
    new Configuration(
        logSuccess: (message, result) => {
            Console.WriteLine($"Input: {message}");
            Console.WriteLine($"Result: {result}");
        }
    )
);

With Pre-execution Commands

await Repl.Run(
    commands: [
        "using static Mykeels.CSharpRepl.Sample.ScriptGlobals;",
        "var greeting = \"Hello, World!\";"
    ]
);

Best Practices

1. Assembly References: Include all necessary assemblies in the references array
2. Namespaces: Add commonly used namespaces to the usings array
3. Error Handling: Implement custom error handling in logError for better debugging
4. Output Formatting: Use AnsiConsole for colored output and better readability
5. Pre-execution Commands: Use commands to set up your environment and import commonly used types

License

This project is licensed under the MIT License - see the LICENSE file for details.

Contributing

Contributions are welcome! Please feel free to submit a Pull Request.