Program.cs

using System;
using System.Diagnostics;
using System.IO;
using System.Runtime.InteropServices;
using System.Text;
using System.Threading;
using System.Windows.Forms;

class Program
{
    private static LowLevelKeyboardProc _proc = HookCallback;
    private static IntPtr _hookID = IntPtr.Zero;

    private static bool isInjecting = false;
    private static bool isInApolloMode = false;

    private static StringBuilder rollingBuffer = new StringBuilder();
    private static StringBuilder commandBuffer = new StringBuilder();
    private static int apolloCharCount = 0;

    // Added '?' to explicitly allow these to be null before they initialize
    private static Process? _pythonProcess;
    private static StreamWriter? _pythonIn;
    private static StreamReader? _pythonOut;

    [STAThread]
    static void Main()
    {
        Console.WriteLine("Apollo System Booting...");
        
        StartPythonEngine();

        _hookID = SetHook(_proc);
        Application.Run();
        
        UnhookWindowsHookEx(_hookID);
        if (_pythonProcess != null && !_pythonProcess.HasExited) 
        {
            _pythonProcess.Kill();
        }
    }

    private static void StartPythonEngine()
    {
        // 1. Check the .exe folder first (for when you publish it later)
        string exeDir = AppDomain.CurrentDomain.BaseDirectory;
        string scriptPath = Path.Combine(exeDir, "apollo_chat.py");

        // 2. If it's not there, check the current working directory (for 'dotnet run' in development)
        if (!File.Exists(scriptPath))
        {
            scriptPath = Path.Combine(Environment.CurrentDirectory, "apollo_chat.py");
        }

        // 3. If it's STILL not there, pause and tell the user!
        if (!File.Exists(scriptPath))
        {
            Console.WriteLine($"\n[ERROR] Could not find 'apollo_chat.py'!");
            Console.WriteLine($"Make sure it is saved in: {Environment.CurrentDirectory}");
            Console.WriteLine("\nPress ENTER to exit...");
            Console.ReadLine(); // Pauses the console so it doesn't instantly vanish
            Environment.Exit(1);
        }

        var startInfo = new ProcessStartInfo
        {
            FileName = "python",
            Arguments = $"\"{scriptPath}\"",
            UseShellExecute = false,
            RedirectStandardInput = true,
            RedirectStandardOutput = true,
            RedirectStandardError = true,
            CreateNoWindow = true,
            StandardOutputEncoding = Encoding.UTF8,
            StandardInputEncoding = Encoding.UTF8,
            StandardErrorEncoding = Encoding.UTF8
        };

        Console.WriteLine("Starting Python AI Engine... (Launching browser)");
        
        try 
        {
            _pythonProcess = Process.Start(startInfo) ?? throw new InvalidOperationException("Failed to start Python.");
        }
        catch (Exception ex)
        {
            Console.WriteLine($"\n[ERROR] Failed to launch Python. Is Python installed and added to your PATH?");
            Console.WriteLine($"Details: {ex.Message}");
            Console.WriteLine("\nPress ENTER to exit...");
            Console.ReadLine();
            Environment.Exit(1);
        }
        
        _pythonIn = _pythonProcess.StandardInput;
        _pythonOut = _pythonProcess.StandardOutput;

        // Forward Python stderr to console so we see any script errors
        var stderrReader = _pythonProcess.StandardError;
        Thread stderrThread = new Thread(() =>
        {
            string? line;
            while ((line = stderrReader.ReadLine()) != null)
                Console.WriteLine("[Python] {0}", line);
        });
        stderrThread.IsBackground = true;
        stderrThread.Start();

        while (true)
        {
            string? line = _pythonOut.ReadLine();
            if (line == "READY") break;
            
            // If the python script crashes (like a syntax error), print it out so we know
            if (line != null && line.Contains("Error", StringComparison.OrdinalIgnoreCase))
            {
                Console.WriteLine($"[PYTHON ERROR] {line}");
            }
        }
        Console.WriteLine("Apollo Engine is READY. Listening for @apo ...");
    }

    private static IntPtr SetHook(LowLevelKeyboardProc proc)
    {
        using Process curProcess = Process.GetCurrentProcess();
        using ProcessModule curModule = curProcess.MainModule!;
        return SetWindowsHookEx(13, proc, GetModuleHandle(curModule.ModuleName), 0);
    }

    private delegate IntPtr LowLevelKeyboardProc(int nCode, IntPtr wParam, IntPtr lParam);
    private const int WM_KEYDOWN = 0x0100;

    private static IntPtr HookCallback(int nCode, IntPtr wParam, IntPtr lParam)
    {
        if (nCode >= 0 && wParam == (IntPtr)WM_KEYDOWN && !isInjecting)
        {
            int vkCode = Marshal.ReadInt32(lParam);
            Keys key = (Keys)vkCode;

            char? typedChar = KeyToChar(key);

            if (typedChar != null)
            {
                rollingBuffer.Append(typedChar);

                if (rollingBuffer.Length > 30)
                    rollingBuffer.Remove(0, rollingBuffer.Length - 30);

                if (!isInApolloMode && rollingBuffer.ToString().EndsWith("@apo"))
                {
                    isInApolloMode = true;
                    commandBuffer.Clear();
                    apolloCharCount = 4;
                }
                else if (isInApolloMode)
                {
                    commandBuffer.Append(typedChar);
                    apolloCharCount++;

                    if (commandBuffer.ToString().EndsWith("@@"))
                    {
                        isInApolloMode = false;
                        apolloCharCount = 0;
                        commandBuffer.Clear();
                        rollingBuffer.Clear();

                        TriggerApollo(); 
                    }
                }
            }

            if (key == Keys.Back)
            {
                if (rollingBuffer.Length > 0)
                    rollingBuffer.Remove(rollingBuffer.Length - 1, 1);

                if (isInApolloMode && apolloCharCount > 0)
                {
                    apolloCharCount--;

                    if (commandBuffer.Length > 0)
                        commandBuffer.Remove(commandBuffer.Length - 1, 1);

                    if (apolloCharCount < 4)
                        isInApolloMode = false;
                }
            }
        }

        return CallNextHookEx(_hookID, nCode, wParam, lParam);
    }

    private static char? KeyToChar(Keys key)
    {
        if (key >= Keys.A && key <= Keys.Z) return key.ToString().ToLower()[0];
        if (key == Keys.Space) return ' ';
        if (key == Keys.D2 && (Control.ModifierKeys & Keys.Shift) != 0) return '@';
        return null;
    }

    private static string? GetChatResponse(string promptText)
    {
        try
        {
            _pythonIn!.WriteLine(promptText);
            _pythonIn!.Flush();

            // Python sends: base64-encoded response line, then "@@END_OF_RESPONSE@@"
            string? line = _pythonOut!.ReadLine();
            if (line == null)
                return "[Error: No response from Python.]";

            if (line == "@@END_OF_RESPONSE@@")
                return string.Empty;

            // Decode base64 payload (response may be multi-line; Python encodes the whole string)
            string result;
            try
            {
                byte[] bytes = Convert.FromBase64String(line);
                result = Encoding.UTF8.GetString(bytes);
            }
            catch
            {
                return "[Error: Invalid response encoding.]";
            }

            _pythonOut.ReadLine(); // consume delimiter
            return result;
        }
        catch (Exception ex)
        {
            Console.WriteLine("Stream error: " + ex.Message);
            return "[Error: Communication with Python lost.]";
        }
    }

    private static void TriggerApollo()
    {
        isInjecting = true;

        Thread macroThread = new Thread(() =>
        {
            try
            {
                // Select from the current cursor position (after @@) backwards up to @apo,
                // possibly spanning multiple lines. We grow the selection upwards until we
                // see "@apo" in the clipboard or we hit a reasonable line limit.
                const int maxSelectionLines = 40;

                SendKeys.SendWait("+{HOME}");
                Thread.Sleep(50);
                SendKeys.SendWait("^c");
                Thread.Sleep(100);

                string clipboardText = Clipboard.GetText();

                int guard = 0;
                while (!clipboardText.Contains("@apo") && guard < maxSelectionLines)
                {
                    guard++;
                    SendKeys.SendWait("+{UP}");
                    Thread.Sleep(50);
                    SendKeys.SendWait("^c");
                    Thread.Sleep(100);
                    clipboardText = Clipboard.GetText();
                }

                string extractedPrompt = "";
                string restOfLine = clipboardText;

                // Use the last occurrence of "@apo" so we bind to the innermost Apollo block
                int start = clipboardText.LastIndexOf("@apo");
                int end = clipboardText.LastIndexOf("@@");

                if (start >= 0 && end > start)
                {
                    extractedPrompt = clipboardText.Substring(start + 4, end - start - 4).Trim();
                    restOfLine = clipboardText.Remove(start, end - start + 2);
                }

                SendKeys.SendWait("{DELETE}");
                Thread.Sleep(50);

                const string placeholder = " processing... ";
                Clipboard.SetText(restOfLine + placeholder);
                SendKeys.SendWait("^v");
                Thread.Sleep(100);

                string? chatResponse = GetChatResponse(extractedPrompt);

                if (!string.IsNullOrEmpty(chatResponse))
                {
                    for (int i = 0; i < placeholder.Length; i++) SendKeys.SendWait("{LEFT}");
                    for (int i = 0; i < placeholder.Length; i++) SendKeys.SendWait("+{RIGHT}");
                    Clipboard.SetText(" " + chatResponse + " ");
                    SendKeys.SendWait("^v");
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine("Macro error: " + ex.Message);
            }
            finally
            {
                isInjecting = false;
            }
        });

        macroThread.SetApartmentState(ApartmentState.STA);
        macroThread.Start();
    }

    #region WinAPI
    [DllImport("user32.dll", CharSet = CharSet.Auto, SetLastError = true)]
    private static extern IntPtr SetWindowsHookEx(int idHook, LowLevelKeyboardProc lpfn, IntPtr hMod, uint dwThreadId);

    [DllImport("user32.dll", CharSet = CharSet.Auto, SetLastError = true)]
    [return: MarshalAs(UnmanagedType.Bool)]
    private static extern bool UnhookWindowsHookEx(IntPtr hhk);

    [DllImport("user32.dll", CharSet = CharSet.Auto, SetLastError = true)]
    private static extern IntPtr CallNextHookEx(IntPtr hhk, int nCode, IntPtr wParam, IntPtr lParam);

    [DllImport("kernel32.dll", CharSet = CharSet.Auto)]
    private static extern IntPtr GetModuleHandle(string? lpModuleName);
    #endregion
}