REAPERSHELL

ReaperShell is an experimental interactive shell
written in .NET 10.

It combines familiar shell commands with a plugin
system built around normal SDK-style .NET projects.

Custom commands can be written in C#, F#, or
VB.NET, compiled, loaded, rebuilt, and reloaded
without restarting the shell.

# WHY IT EXISTS

ReaperShell is a playground for building local
tools without turning every small automation task
into a separate application.

A tool can begin as a quick experiment, grow into
a proper command project, and still remain easy to
edit, rebuild, reload, and use from the shell.

One of the early proving grounds was an IIS tools
command pack that grew out of a lost PowerShell
script. (Update: I found the original!)

That project helped turn ReaperShell from an idea
into something I could actually use.

# VIBECODING EXPERIMENT

ReaperShell is my first, and so far only, fully
vibecoded project.

I started it partly as an experiment during a
free month of ChatGPT Plus to see how far I could
push AI-assisted development across an entire
project.

Unlike my other projects, I have NOT fully
reviewed all of the generated code.

I have directed the project, chosen features,
tested behavior, reported bugs, made architectural
decisions, and pushed the development in the
directions I wanted.

ChatGPT and Codex have done most of the actual
implementation work.

That was intentional.

The experiment was not just:

"Can AI generate some useful C#?"

I already knew it could.

I wanted to see what happens when I let AI work
across a growing codebase for an extended period,
with me acting more like the person directing and
testing the project than the person personally
writing and inspecting every line.

That makes ReaperShell an experiment in two things
at once:

* Building an extensible .NET shell
* Seeing how far full-project vibecoding can
  actually be pushed

The result is software I genuinely use, but it is
also code I would not claim to understand or have
personally audited line by line.

That is part of the experiment.

# FEATURES

* Interactive shell execution
* One-shot command execution
* Script files
* Startup profiles
* Command history
* Aliases
* Session environment variables
* File and directory commands
* Path completion
* Command source inspection
* Environment diagnostics
* Rituals and event hooks
* Hot-loadable command packs
* C#, F#, and VB.NET command projects
* Git-backed command-pack management
* Explicit Git branch switching
* Build, load, reload, and reload-all workflows
* Command scaffolding
* Configurable editor integration

# COMMAND PACKS

ReaperShell command packs are regular .NET
projects.

They are not a custom scripting language.

A pack contains normal SDK-style command projects
that implement ReaperShell's command interface.

Supported project types include:

* .csproj
* .fsproj
* .vbproj

This means commands can use normal .NET tooling,
packages, project files, editors, and debuggers.

Command packs can be local directories or
Git-backed repositories.

# GIT WORKFLOW

ReaperShell can manage Git-backed command packs
without leaving the shell.

It can:

* Register or clone repositories
* Show repository status
* List branches
* Explicitly switch branches
* Pull with fast-forward-only behavior
* Build and reload commands
* Commit changes
* Push changes
* Save by committing and pushing
* Publish a local pack to GitHub

Reloading does not silently pull or change
branches.

The shell tells you which branch and commit are
being rebuilt so there is less opportunity for:

"Why the hell am I still running the old code?"

# RITUALS AND HOOKS

ReaperShell also has reusable scripts called
rituals.

Rituals can be run manually or attached to shell
events using hooks.

This gives me a small automation system inside
the shell without needing to invent yet another
scripting language.

# INTROSPECTION

Commands such as:

which
describe
source
status
doctor

help inspect where commands came from, what is
loaded, and whether the current environment is
sane.

This became especially useful once command packs
started being rebuilt and reloaded from different
Git branches.

# SECURITY

Command packs run in-process with the permissions
of the current user.

ReaperShell is NOT a security sandbox.

Repositories must be explicitly trusted before
their command code is loaded.

Only command packs you trust should be executed.

# STATUS

ReaperShell is experimental, but it has grown
well past the original shell prototype.

It is still primarily a playground for shell
design, local automation, plugin loading, and
developer tooling rather than an attempt to
replace PowerShell, Bash, or another general
purpose shell.

# SOURCE CODE

https://github.com/JoyfulReaper/ReaperShell

License:
MIT

Copyright 2026 Kyle Givler
.