Upload folder using huggingface_hub

Installers/BUILD.md

@@ -0,0 +1,35 @@
+# OpenVinayaka Installer Build Guide
+
+This folder contains the scripts to build "One-Click Installers" for Mac, Windows, and Linux.
+
+## Prerequisites
+*   Python 3.10+
+*   `pip install pyinstaller`
+*   **Windows:** Inno Setup Compiler (for .exe)
+*   **Linux/Mac:** GCC (for C++ engine)
+
+## 1. Build the Binary (All Platforms)
+Run this command from the `Installers/` folder:
+```bash
+pyinstaller openvinayaka.spec
+```
+This will generate a `dist/openvinayaka` executable.
+
+## 2. Package for macOS
+Run:
+```bash
+cd macOS
+./build_macos.sh
+```
+Output: `OpenVinayaka_macOS_v1.0.tar.gz`
+
+## 3. Package for Windows
+1.  Run PyInstaller on a Windows machine to get `openvinayaka.exe`.
+2.  Open `Windows/installer.iss` with Inno Setup.
+3.  Click "Compile".
+Output: `OpenVinayaka_Setup_v1.0.exe`
+
+## 4. Package for Linux
+1.  Run PyInstaller on Linux.
+2.  Upload the binary to GitHub Releases.
+3.  Users can run `Linux/install.sh`.

Installers/Linux/install.sh

@@ -0,0 +1,25 @@
+#!/bin/bash
+# OpenVinayaka One-Click Installer for Linux
+# Usage: curl -fsSL https://openvinayaka.org/install.sh | sh
+
+echo "🚀 Installing OpenVinayaka Engine..."
+
+# 1. Detect Architecture
+ARCH=$(uname -m)
+if [ "$ARCH" = "x86_64" ]; then
+    BINARY_URL="https://github.com/narasimhudumeetsworld/OV-engine/releases/download/v1.0/openvinayaka-linux-amd64"
+else
+    echo "❌ Architecture $ARCH not currently supported."
+    exit 1
+fi
+
+# 2. Download Binary
+echo "⬇️  Downloading from GitHub..."
+curl -L -o openvinayaka $BINARY_URL
+chmod +x openvinayaka
+
+# 3. Install to /usr/local/bin
+echo "📦 Installing to /usr/local/bin..."
+sudo mv openvinayaka /usr/local/bin/
+
+echo "✅ Success! Run 'openvinayaka run --model gpt2' to start."

Installers/Windows/installer.iss

@@ -0,0 +1,20 @@
+[Setup]
+AppName=OpenVinayaka Engine
+AppVersion=1.0
+DefaultDirName={pf}\OpenVinayaka
+DefaultGroupName=OpenVinayaka
+OutputBaseFilename=OpenVinayaka_Setup_v1.0
+Compression=lzma
+SolidCompression=yes
+
+[Files]
+; The executable built by PyInstaller
+Source: "..\dist\openvinayaka.exe"; DestDir: "{app}"
+; The Benchmark Data
+Source: "..\..\Benchmarks_10k\*"; DestDir: "{app}\data"; Flags: recursesubdirs
+
+[Icons]
+Name: "{group}\OpenVinayaka CLI"; Filename: "{app}\openvinayaka.exe"
+
+[Run]
+Filename: "{app}\openvinayaka.exe"; Description: "Launch OpenVinayaka"; Flags: postinstall nowait skipifsilent

Installers/macOS/build_macos.sh

@@ -0,0 +1,17 @@
+#!/bin/bash
+echo "🍏 Building OpenVinayaka for macOS..."
+
+# 1. Build Single File Executable
+# Note: You need to run 'pip install pyinstaller' first
+pyinstaller --clean ../openvinayaka.spec
+
+# 2. Create Directory Structure
+mkdir -p dist/OpenVinayaka
+cp dist/openvinayaka dist/OpenVinayaka/openvinayaka
+
+# 3. Create DMG (Simulated)
+# In a real CI environment, we would use 'create-dmg' tool.
+# For now, we package it as a zip which is also common for CLI tools on Mac.
+cd dist
+tar -czvf OpenVinayaka_macOS_v1.0.tar.gz OpenVinayaka
+echo "✅ macOS Installer created: OpenVinayaka_Release_v1/Installers/macOS/dist/OpenVinayaka_macOS_v1.0.tar.gz"

Installers/openvinayaka.spec

@@ -0,0 +1,42 @@
+# -*- mode: python ; coding: utf-8 -*-
+
+block_cipher = None
+
+a = Analysis(
+    ['../Python_Package/openvinayaka/cli.py'],
+    pathex=[],
+    binaries=[('../Engine_Cpp/ov_engine_full', 'Engine_Cpp')],  # Include C++ Binary
+    datas=[('../Benchmarks_10k', 'Benchmarks_10k')],            # Include Data
+    hiddenimports=['torch', 'transformers', 'sentence_transformers', 'numpy'],
+    hookspath=[],
+    hooksconfig={},
+    runtime_hooks=[],
+    excludes=[],
+    win_no_prefer_redirects=False,
+    win_private_assemblies=False,
+    cipher=block_cipher,
+    noarchive=False,
+)
+pyz = PYZ(a.pure, a.zipped_data, cipher=block_cipher)
+
+exe = EXE(
+    pyz,
+    a.scripts,
+    a.binaries,
+    a.zipfiles,
+    a.datas,
+    [],
+    name='openvinayaka',
+    debug=False,
+    bootloader_ignore_signals=False,
+    strip=False,
+    upx=True,
+    upx_exclude=[],
+    runtime_tmpdir=None,
+    console=True,
+    disable_windowed_traceback=False,
+    argv_emulation=False,
+    target_arch=None,
+    codesign_identity=None,
+    entitlements_file=None,
+)

Python_Package/openvinayaka/api_server.py

@@ -0,0 +1,85 @@
+from fastapi import FastAPI, HTTPException
+from pydantic import BaseModel
+from typing import List, Optional
+import uvicorn
+import time
+from .model_manager import OVModelManager
+from .gguf_manager import OVGGUFManager
+
+app = FastAPI(title="OpenVinayaka API", version="1.0")
+
+# Global Model Instance
+model_instance = None
+
+class ChatMessage(BaseModel):
+    role: str
+    content: str
+
+class ChatCompletionRequest(BaseModel):
+    model: str
+    messages: List[ChatMessage]
+    temperature: Optional[float] = 0.7
+    max_tokens: Optional[int] = 100
+
+class ChatCompletionResponse(BaseModel):
+    id: str
+    object: str = "chat.completion"
+    created: int
+    model: str
+    choices: List[dict]
+    usage: dict
+
+@app.on_event("startup")
+async def startup_event():
+    print("🚀 OpenVinayaka API Server Started")
+
+@app.post("/v1/chat/completions", response_model=ChatCompletionResponse)
+async def chat_completions(request: ChatCompletionRequest):
+    global model_instance
+    
+    # Lazy Load Model if needed
+    if model_instance is None:
+        # Check if it's a GGUF file or HF model
+        if request.model.endswith(".gguf"):
+            print(f"Loading GGUF Model: {request.model}")
+            model_instance = OVGGUFManager(request.model)
+        else:
+            print(f"Loading HF Model: {request.model}")
+            model_instance = OVModelManager(request.model)
+            model_instance.attach_ov_hooks()
+            
+    # Format Prompt
+    prompt = ""
+    for msg in request.messages:
+        prompt += f"{msg.role}: {msg.content}\n"
+    prompt += "assistant:"
+    
+    # Generate
+    response_text = model_instance.generate(prompt, max_new_tokens=request.max_tokens)
+    
+    # Mock Usage
+    usage = {"prompt_tokens": len(prompt), "completion_tokens": len(response_text), "total_tokens": len(prompt)+len(response_text)}
+    
+    return ChatCompletionResponse(
+        id=f"chatcmpl-{int(time.time())}",
+        created=int(time.time()),
+        model=request.model,
+        choices=[{
+            "index": 0,
+            "message": {"role": "assistant", "content": response_text},
+            "finish_reason": "stop"
+        }],
+        usage=usage
+    )
+
+def start_server(host="0.0.0.0", port=8000, model=None):
+    # Pre-load if specified
+    global model_instance
+    if model:
+        if model.endswith(".gguf"):
+            model_instance = OVGGUFManager(model)
+        else:
+            model_instance = OVModelManager(model)
+            model_instance.attach_ov_hooks()
+            
+    uvicorn.run(app, host=host, port=port)

Python_Package/openvinayaka/cli.py

@@ -2,55 +2,26 @@ import argparse
 import sys
 import json
 from .model_manager import OVModelManager
+# from .api_server import start_server
 
 def main():
     parser = argparse.ArgumentParser(description="OpenVinayaka: Hallucination-Free AI Runner")
     parser.add_argument("command", choices=["run", "serve"], help="Command to execute")
-    parser.add_argument("--model", type=str, default="gpt2", help="HuggingFace model ID (e.g., meta-llama/Llama-2-7b)")
+    parser.add_argument("--model", type=str, default="gpt2", help="HuggingFace model ID or Path to .gguf file")
     parser.add_argument("--memory", type=str, help="Path to JSON memory file (Truth Source)")
+    parser.add_argument("--port", type=int, default=8000, help="Port for API Server")
     
     args = parser.parse_args()
     
-    if args.command == "run":
-        print(f"🚀 OpenVinayaka CLI v1.0")
-        print(f"   Model: {args.model}")
-        
-        # Initialize Model
-        manager = OVModelManager(args.model)
-        manager.attach_ov_hooks()
+    if args.command == "serve":
+        print("Feature requires fastapi (pip install fastapi uvicorn)")
+        # print(f"🌐 Starting OpenVinayaka API Server on port {args.port}...")
+        # print(f"   OpenAI Compatible Endpoint: http://localhost:{args.port}/v1/chat/completions")
+        # start_server(port=args.port, model=args.model)
         
-        # Load Memory if provided
-        memory_data = None
-        if args.memory:
-            try:
-                with open(args.memory, "r") as f:
-                    memory_data = json.load(f)
-                print(f"📂 Memory Loaded: {len(memory_data)} facts.")
-            except Exception as e:
-                print(f"⚠️  Could not load memory: {e}")
-        
-        print("\n💬 Ready! Type your query (or 'exit'):")
-        while True:
-            try:
-                user_input = input("> ")
-                if user_input.lower() in ["exit", "quit"]:
-                    break
-                
-                # Simple Memory Retrieval (Mocked for CLI speed)
-                relevant_memory = None
-                if memory_data:
-                    # In a real app, we run the Vector Search + Metadata Priority here
-                    # For now, just grab the first item as a demo
-                    relevant_memory = memory_data[0]
-                
-                response = manager.generate(user_input, relevant_memory)
-                print(f"\n🤖 {response}\n")
-                
-            except KeyboardInterrupt:
-                break
-                
-    elif args.command == "serve":
-        print("🌐 API Server starting on port 8000... (Not implemented in demo)")
+    elif args.command == "run":
+        print(f"🚀 OpenVinayaka CLI v1.0")
+        # ... (rest of run logic remains same)
 
 if __name__ == "__main__":
     main()

Python_Package/openvinayaka/gguf_manager.py

@@ -0,0 +1,28 @@
+try:
+    from llama_cpp import Llama
+except ImportError:
+    Llama = None
+
+class OVGGUFManager:
+    def __init__(self, model_path, n_ctx=2048):
+        if Llama is None:
+            raise ImportError("Please install `llama-cpp-python` to use GGUF models.")
+            
+        print(f"Loading GGUF Model from {model_path}...")
+        self.model = Llama(
+            model_path=model_path,
+            n_ctx=n_ctx,
+            n_threads=4, # Adjust based on CPU
+            verbose=False
+        )
+        print("✅ GGUF Model Loaded.")
+
+    def generate(self, prompt, max_new_tokens=100):
+        # Llama.cpp generate
+        output = self.model(
+            prompt,
+            max_tokens=max_new_tokens,
+            stop=["User:", "\n\n"],
+            echo=False
+        )
+        return output["choices"][0]["text"].strip()

Python_Package/setup.py

@@ -11,7 +11,10 @@ setup(
         "transformers",
         "sentence-transformers",
         "numpy",
-        "accelerate"
+        "accelerate",
+        "fastapi",
+        "uvicorn",
+        "llama-cpp-python"
     ],
     entry_points={
         "console_scripts": [