From Educational Shell to AI-Powered Terminal: Finishing My C++ Project with Local LLMs

This is a submission for the GitHub Finish-Up-A-Thon Challenge

What I Built

I built MyShell, a customizable command-line shell written in C++ for Windows that combines a Linux-style command experience with local AI-powered command translation.

This project started as a purely educational project. My goal was to understand how terminals and operating systems work behind the scenes by building a shell from scratch. Instead of only learning the theory, I wanted to explore command parsing, process creation, file system operations, and terminal interfaces by implementing them myself.

The shell originally provided basic commands such as directory navigation, file operations, and external command execution. It was a great way to learn how a terminal communicates with the operating system and how command interpreters are structured internally.

When I discovered the GitHub Finish-Up-A-Thon Challenge, I saw it as the perfect opportunity to revisit the project and push it much further than its original educational scope. Rather than leaving it as a learning experiment, I decided to transform it into a more complete and modern terminal experience by adding AI-powered features, safer command execution, and a cleaner architecture.

Today, MyShell supports built-in commands, external program execution, command chaining, file management, and natural language interaction powered by a local LLM.

One of the main goals of the project is to make command-line interfaces more approachable. Instead of memorizing commands, users can simply describe what they want to do and let the shell translate their request into executable commands.

Screenshot

Repository

GitHub Repository:

https://github.com/MohamedAli1937/Cpp-Shell

Features Demonstrated

• Linux-style commands on Windows (ls, pwd, mkdir, touch, rm)
• External program execution
• Command chaining with &&
• AI-powered natural language command translation
• Safety previews and confirmation prompts for potentially dangerous operations
• Local LLM integration through llama.cpp

Example

ai create folder src and a file main.cpp inside

Translated into:

mkdir src && cd src && touch main.cpp

The shell then analyzes the generated command, checks its risk level, shows a preview when necessary, and executes it after user confirmation.

Since the AI runs locally through llama.cpp, no cloud API is required and users can choose whichever GGUF model they prefer.

The Comeback Story

When I started this challenge, MyShell was already working but felt unfinished.

The original version included:

• Basic command parsing
• Directory navigation
• File and folder operations
• External command execution
• Colored terminal output

It successfully achieved its educational purpose, but there were many ideas that I had never implemented.

The Finish-Up-A-Thon gave me the motivation to finally return to the project and build the features I had been postponing.

What I Added

🤖 AI Command Translation

The biggest addition was a local AI system that allows users to interact with the shell using natural language.

Instead of typing commands manually, users can now write:

ai show me all files

and the shell automatically translates it into:

ls

More complex requests can also be converted into multiple commands:

ai create folder src and a file main.cpp inside

↓

mkdir src && cd src && touch main.cpp

🛡️ Safety Layer

AI-generated commands can be powerful, but they can also be dangerous.

To make the feature safer, I implemented:

• Command planning
• Risk classification
• Dangerous operation detection
• Confirmation prompts before execution

This prevents accidental destructive operations while keeping the workflow simple.

🔗 Command Chaining

I added support for chained commands using &&, making it possible to execute complete workflows in a single instruction.

📁 Improved File Operations

The shell gained:

• touch command support
• Multiple file creation
• Multiple folder creation
• Recursive deletion support
• Better command handling

🏗️ Better Architecture

To support future growth, I reorganized the project into dedicated AI modules:

• AIManager
• LLMInterface
• CommandPlanner
• SafetyChecker
• Preview

This separation made the codebase cleaner and easier to maintain.

The project now feels much closer to the vision I originally had: a customizable shell that combines traditional command-line workflows with modern AI assistance.

My Experience with GitHub Copilot

GitHub Copilot played a significant role during the AI upgrade phase of this project.

One area where it helped a lot was building the communication layer between MyShell and the local llama.cpp server. Working with WinHTTP in C++ can be verbose, and Copilot frequently suggested the boilerplate required for HTTP requests, response handling, and error checking, which saved a considerable amount of time.

It was also useful when creating the new AI architecture. While designing classes such as AIManager, LLMInterface, CommandPlanner, and SafetyChecker, Copilot often completed repetitive class definitions, constructors, and method implementations, allowing me to focus more on the overall design of the system.

Another place where it helped was command-processing logic. When implementing command chaining, argument parsing, and safety checks, Copilot suggested code patterns that sped up development and helped reduce repetitive typing.

I still made all architectural decisions myself, but Copilot acted like a pair programmer that handled much of the boilerplate while I focused on the behavior and user experience of the shell.

For a project that combines systems programming, command parsing, and AI integration, that productivity boost was incredibly valuable.

What's Next?

MyShell is still evolving. Some features I would like to add next include:

• Command piping (|)
• I/O redirection (>, <)
• Background process execution
• Smarter context-aware AI command generation
• Additional built-in commands
• Cross-platform support
• Better support for local AI models

This challenge helped me transform MyShell from a simple educational experiment into a much more complete project. More importantly, it gave me a reason to finally finish features that had been sitting in my backlog for months.

Thanks to GitHub and DEV for organizing the Finish-Up-A-Thon and motivating developers to bring unfinished projects back to life.