Update report.md

report.md

@@ -26,6 +26,12 @@ graph TD
             G[Start-up Check]
         end
         
+        subgraph "Hardware Layer"
+            E[CPU - AVX/AVX2]
+            F[RAM]
+            G[Start-up Check]
+        end
+        
         G -- Detects Flags --> A
         A -- Selects Binary --> C
         C -- Loads --> H[model.gguf]
@@ -37,6 +43,8 @@ graph TD
 
 ### 2.2 Component Breakdown
 
+### 2.2 Component Breakdown
+
 1.  **Electron Main Process (`main.js`)**:
     *   **Role**: The application entry point and central controller.
     *   **New Capabilities**:
@@ -53,27 +61,36 @@ graph TD
 2.  **Native AI Engine (Backend)**:
     *   **Role**: The "Brain" of the application.
     *   **Technology**: Pre-compiled binaries (likely based on `llama.cpp`) optimized for CPU inference.
-    *   **Binaries**: `bujji_engine.exe` located in `engine/cpu_avx/` and `engine/cpu_avx2/`.
     *   **Operation**: Runs a local server on port `5000`.
     *   **Model**: Loads weights strictly from a file named `model.gguf`.
-    *   **No Python Required**: The binary is self-contained.
-    *   **Git LFS integration**: Large binaries (`.exe`, `.dll`) are tracked via Git LFS.
+    *   **No Python Required**: The binary is self-contained with all necessary DLLs.
+    *   **Git LFS integration**: Large binaries (`.exe`, `.dll`) are tracked via Git LFS to keep the repo clean. The `main.js` includes a startup check to ensure these files are fully downloaded (and not just LFS pointers) before launching.
 
 3.  **TTS Engine (Piper)**:
     *   **Role**: Text-to-Speech synthesis — converts typed text into natural-sounding speech.
     *   **Technology**: Piper TTS (`piper.exe`), an ONNX-based neural TTS engine.
-    *   **Binaries**: `piper.exe` in `engine/cpu_avx/` and `engine/cpu_avx2/`.
+    *   **Operation**: Invoked on-demand via IPC. Text is piped to `piper.exe` stdin, and a `.wav` file is generated as output.
     *   **Model**: `en_US-lessac-medium.onnx` (English, medium quality voice) stored in `engine/piper/`.
-    *   **Bundled DLLs**: `piper_phonemize.dll`, `onnxruntime.dll`, `espeak-ng.dll`.
-    *   **Output**: WAV audio files saved to the system temp directory.
+    *   **DLLs**: `piper_phonemize.dll`, `onnxruntime.dll`, `espeak-ng.dll` bundled in the engine directory.
+    *   **Output**: WAV audio files saved to the system temp directory, playable in-app with a download option.
 
 4.  **STT Engine (Whisper Server)**:
     *   **Role**: Speech-to-Text transcription — extracts text from audio files.
     *   **Technology**: Whisper.cpp server build (`whisper.exe`), runs as an HTTP server.
-    *   **Binaries**: `whisper.exe` in `engine/cpu_avx/` and `engine/cpu_avx2/`.
+    *   **Operation**: Started on-demand on port `5001`. Audio files are POSTed to `/inference` endpoint as multipart form-data. Server is shut down after each transcription.
     *   **Model**: `ggml-base.en.bin` (English base model) stored in `engine/whisper/`.
-    *   **Bundled DLLs**: `whisper.dll`, `ggml.dll`.
-    *   **Audio Format Support**: `.wav`, `.mp3`, `.m4a`, `.ogg`, `.flac` — requires `ffmpeg.exe` and `ffmpeg.dll` in `bin/`.
+    *   **DLLs**: `whisper.dll`, `ggml.dll` bundled in the engine directory.
+    *   **Audio Format Support**: `.wav`, `.mp3`, `.m4a`, `.ogg`, `.flac` — requires `ffmpeg.exe` and `ffmpeg.dll` in `bin/` for automatic audio conversion.
+    *   **Input**: User selects an audio file via native file dialog.
+
+5.  **Renderer Process (`index.html` + `renderer.js`)**:
+    *   **Role**: The User Interface.
+    *   **Responsibilities**:
+        *   Displays the chat interface.
+        *   Sends user prompts to `localhost:5000`.
+        *   Receives and streams AI responses.
+        *   Provides TTS interface (text input → speech generation → audio playback/download).
+        *   Provides STT interface (file upload → transcription → text display/copy).
 
 ## 3. Operational Flow Chart
 
@@ -108,18 +125,60 @@ sequenceDiagram
     W-->>U: Display Chat Interface
 ```
 
+### 3.2 TTS Flow
+
+```mermaid
+sequenceDiagram
+    participant U as User
+    participant R as Renderer (UI)
+    participant M as Main Process
+    participant P as Piper TTS Engine
+
+    U->>R: Types text, clicks "Speak"
+    R->>M: IPC: tts-synthesize(text)
+    M->>P: Spawn piper.exe, pipe text to stdin
+    P-->>M: Generates .wav file
+    M-->>R: Returns .wav file path
+    R-->>U: Plays audio, shows Download button
+    U->>R: Clicks "Download Audio"
+    R->>M: IPC: tts-save-file(path)
+    M-->>U: Native Save dialog, copies file
+```
+
+### 3.3 STT Flow
+
+```mermaid
+sequenceDiagram
+    participant U as User
+    participant R as Renderer (UI)
+    participant M as Main Process
+    participant W as Whisper Server
+
+    U->>R: Clicks "Browse", selects audio file
+    R->>M: IPC: stt-select-file()
+    M-->>R: Returns file path (native dialog)
+    U->>R: Clicks "Transcribe"
+    R->>M: IPC: stt-transcribe(filePath)
+    M->>W: Start whisper.exe server (port 5001)
+    M->>W: POST audio to /inference
+    W-->>M: Returns transcription JSON
+    M->>W: Kill server
+    M-->>R: Returns transcribed text
+    R-->>U: Displays text, shows Copy button
+```
+
 ## 4. Technical Specifications & Requirements
 
 ### 4.1 Prerequisites
 *   **Operating System**: Windows (10/11) 64-bit.
-*   **Software**: Git & Git LFS (Required for downloading engine binaries).
+*   **software**: Git & Git LFS (Required for downloading engine binaries).
 *   **Runtime**: Node.js (LTS version recommended).
 *   **Hardware**: 
     *   Any modern CPU (Intel/AMD) with AVX support.
     *   Minimum 8GB RAM (16GB recommended for larger models).
     *   Disk space proportional to the model size (e.g., 4GB for a 7B model).
 
-### 4.2 File Structure & Dependencies
+### 4.2 File Structure
 The critical file structure required for the app to function:
 
 ```text
@@ -133,24 +192,38 @@ Root/
 │   │   ├── bujji_engine.exe
 │   │   ├── piper.exe
 │   │   └── whisper.exe
+│   ├── piper/                  # TTS model & config
+│   │   └── en_US-lessac-medium.onnx
+│   └── whisper/                # STT model
+│       └── ggml-base.en.bin
 ├── bin/                        # Utility binaries
 │   ├── ffmpeg.exe              # Audio conversion (required for STT)
 │   ├── ffmpeg.dll              # FFmpeg library
 │   └── ffplay.exe              # Audio playback
-├── model.gguf                  # The AI Model
+├── assets/icons/               # Local SVG icons
+├── model.gguf                  # The AI Model (Must be named exactly this)
+├── main.js                     # Core Logic (Main Process)
+├── index.html                  # UI Layer
+├── renderer.js                 # Frontend Logic
+├── styles.css                  # Styling
+├── web.html                    # Built-in Web Browser
 ├── package.json                # Dependencies
-└── node_modules/               # Installed via npm install
+└── node_modules/               # Installed via npm install (includes lucide, marked)
 ```
 
 ### 4.3 Framework Constraints & Packaging
 
 *   **Model Format Support**:
-    *   **Text Generation**: Strictly requires **GGUF** format.
+    *   **Text Generation**: Strictly requires **GGUF** format (`llama.cpp` compatible).
     *   **Speech-to-Text**: Requires **GGML Binary** format (`ggml-*.bin`).
     *   **Text-to-Speech**: Requires **ONNX** format (`.onnx` + `.json` config).
-*   **Packaging Limit**:
-    *   The framework uses **NSISBI** (Large Installer Support).
-    *   **Tested Packaging Size**: Up to **~3.1GB** successfully.
+    *   *Note: Python-based models (`.pt`, `.safetensors`) are NOT supported to ensure zero-dependency offline execution.*
+
+*   **Packaging Capabilities**:
+    *   **Installer Engine**: Uses **NSISBI** (NSIS Large Integrated Browser Installer) to bypass the standard 2GB limit.
+    *   **Verified Capacity**: The framework has been tested to successfully package applications up to **~3.1GB** (Base App + Engine + Model).
+    *   **Recommendation**: efficient for bundling quantized models (e.g., Llama-3-8B-Q4_K_M) directly into a single `.exe` file.
+
 
 ## 5. Offline-First Architecture
 
@@ -159,23 +232,20 @@ The framework is designed to be **100% offline-capable** after initial setup:
 *   **No CDN Dependencies**: All frontend libraries (Lucide icons, Marked.js) are bundled locally via `node_modules/`.
 *   **Local Engine Binaries**: All AI engines (`bujji_engine.exe`, `piper.exe`, `whisper.exe`) and their DLLs are included in the `engine/` directory.
 *   **Bundled Models**: TTS model (`en_US-lessac-medium.onnx`), STT model (`ggml-base.en.bin`), and the LLM model (`model.gguf`) are all stored locally.
+*   **Content Security Policy**: The CSP in `index.html` is configured to only allow `'self'` and the local API server (`127.0.0.1:5000`), blocking all external network requests.
 *   **Audio Utilities**: `ffmpeg.exe` and `ffplay.exe` are bundled in `bin/` for audio format conversion and playback.
 
 ## 6. Development & Open Source Strategy
 
-### 6.1 Licensing & Credits
-The RemiAI Framework is released under the **MIT License**, permitting free use, modification, and distribution.
-
-#### Third-Party Components
-This project relies on robust open-source projects. We gratefully acknowledge:
-*   **Llama.cpp** (Backend `bujji_engine.exe`): [MIT License](https://github.com/ggerganov/llama.cpp)
-*   **Piper TTS** (Speech Synthesis): [MIT License](https://github.com/rhasspy/piper)
-*   **Whisper.cpp** (Speech Recognition): [MIT License](https://github.com/ggerganov/whisper.cpp)
-*   **Gemma 2 Model** (AI Weights): [Gemma Terms of Use](https://ai.google.dev/gemma/terms)
+### 6.1 Licensing
+This project is released under the **MIT License**. This allows any student or developer to:
+*   Use the code freely.
+*   Modify the interface (rename "RemiAI" to their own brand).
+*   Distribute their own versions.
 
 ### 6.2 Hosting Strategy
 *   **GitHub**: Contains the source code (JS, HTML, CSS).
 *   **Hugging Face**: Hosts the large `model.gguf` file and the zipped release builds due to storage limits on GitHub. We use Hugging Face for "Large File Storage" of the AI weights.
 
 ## 7. Conclusion
-The RemiAI/Bujji framework democratizes access to local AI. By removing the complex Python environment setup and packaging the inference engine directly with the app, we enable any student with a laptop to run powerful AI models simply by typing `npm start`.
+The RemiAI/Bujji framework democratizes access to local AI. By removing the complex Python environment setup and packaging the inference engine directly with the app, we enable any student with a laptop to run powerful AI models simply by typing `npm start`. With integrated TTS (Piper) and STT (Whisper) capabilities, the framework now provides a complete offline AI assistant experience — text generation, speech synthesis, and speech recognition — all running locally without any internet connection or cloud services.