lmms-builder 1.0.0__py3-none-any.whl

lmms_builder/__init__.py

@@ -0,0 +1,3 @@
+"""
+LMMS Builder - Bootstrapper for the LMMs OS
+"""

lmms_builder/autoset.py

@@ -0,0 +1,87 @@
+import json
+from pathlib import Path
+
+from . import hardware
+from . import bootstrap
+from . import installer
+from . import reporter
+
+def write_default_config(lmms_dir, mode="engine"):
+    config_dir = lmms_dir / "config"
+    config_dir.mkdir(parents=True, exist_ok=True)
+    config_file = config_dir / "config.json"
+    
+    config = {}
+    if config_file.exists():
+        try:
+            with open(config_file, "r") as f:
+                config = json.load(f)
+        except Exception:
+            pass
+            
+    config["default_mode"] = mode
+    
+    with open(config_file, "w") as f:
+        json.dump(config, f, indent=4)
+
+def determine_default_runtime(hw):
+    if hw['gpu']['detected'] and hw['gpu']['vram_gb'] >= 4:
+        return "llama.cpp"
+    return "ollama"
+
+def recommend_model(hw):
+    ram = hw['ram']['total_gb']
+    vram = hw['gpu']['vram_gb'] if hw['gpu']['detected'] else 0
+    
+    if vram >= 16 or (ram >= 32 and vram == 0):
+        return "Qwen2.5-Coder-7B or Llama3.2-8B"
+    elif vram >= 8 or (ram >= 16 and vram == 0):
+        return "Qwen2.5-Coder-3B or Gemma3-4B"
+    else:
+        return "Qwen2.5-1.5B or Llama-3.2-1B"
+
+def run_autoset(components):
+    reporter.print_header()
+    
+    reporter.print_step("Detecting Hardware...")
+    hw = hardware.detect_all()
+    reporter.print_hardware_report(hw)
+    
+    recommended = recommend_model(hw)
+    reporter.print_step(f"Based on hardware, recommended model: {recommended}")
+    
+    reporter.print_step("Evaluating Compatibility...")
+    reporter.print_compatibility_report(hw)
+    
+    reporter.print_step("Validating Python Environment...")
+    if not installer.check_python_version():
+        reporter.print_error("Python >= 3.9 required.")
+        return False
+        
+    reporter.print_step("Ensuring core Python build tools...")
+    installer.ensure_base_tools()
+    
+    reporter.print_step("Bootstrapping ~/.lmms directory structure...")
+    lmms_dir = bootstrap.run_bootstrap()
+    
+    reporter.print_step("Installing requested components...")
+    
+    # components is a dict: {"all": bool, "engine": bool, ...}
+    # Loop over the keys. If 'all' is true, install all. Otherwise, install selected.
+    comps_to_install = ["engine", "gui", "cli", "backend", "air"]
+    
+    for comp in comps_to_install:
+        if components.get("all") or components.get(comp):
+            installer.install_component(comp)
+            
+    reporter.print_step("Determining optimal runtime...")
+    runtime = determine_default_runtime(hw)
+    
+    reporter.print_step("Writing configuration...")
+    # Default to engine. If user specifically installed GUI or CLI, we could change this,
+    # but the plan specified setting default mode to engine for now.
+    mode = "engine"
+    write_default_config(lmms_dir, mode)
+    
+    reporter.print_autoset_summary(mode, runtime)
+    return True

lmms_builder/bootstrap.py

@@ -0,0 +1,50 @@
+import os
+from pathlib import Path
+
+def setup_directory_structure():
+    home = Path.home()
+    lmms_dir = home / ".lmms"
+    
+    dirs_to_create = [
+        lmms_dir,
+        lmms_dir / "models",
+        lmms_dir / "memory",
+        lmms_dir / "cache",
+        lmms_dir / "logs",
+        lmms_dir / "workspaces",
+        lmms_dir / "tasks",
+        lmms_dir / "agents",
+        lmms_dir / "runtime",
+        lmms_dir / "git",
+        lmms_dir / "db",
+        lmms_dir / "config",
+    ]
+    
+    for d in dirs_to_create:
+        d.mkdir(parents=True, exist_ok=True)
+        
+    return lmms_dir
+
+def initialize_databases(lmms_dir):
+    db_dir = lmms_dir / "db"
+    
+    db_files = [
+        "workspace.db",
+        "memory.db",
+        "action_ledger.db",
+        "task.db"
+    ]
+    
+    for db_file in db_files:
+        (db_dir / db_file).touch(exist_ok=True)
+        
+def create_default_workspace(lmms_dir):
+    ws_dir = lmms_dir / "workspaces" / "default"
+    ws_dir.mkdir(parents=True, exist_ok=True)
+    return ws_dir
+
+def run_bootstrap():
+    lmms_dir = setup_directory_structure()
+    initialize_databases(lmms_dir)
+    create_default_workspace(lmms_dir)
+    return lmms_dir

lmms_builder/cli.py

@@ -0,0 +1,104 @@
+import argparse
+import sys
+
+from . import hardware
+from . import autoset
+from . import reporter
+
+def main():
+    parser = argparse.ArgumentParser(prog="lmms-builder", description="Bootstrapper for LMMs OS")
+    parser.add_argument("--autoset", action="store_true", help="Run the fully automated install workflow")
+    
+    # Root level autoset sub-flags
+    parser.add_argument("--all", action="store_true", help="Install all components")
+    parser.add_argument("--engine", action="store_true", help="Install the core Engine")
+    parser.add_argument("--gui", action="store_true", help="Install the GUI")
+    parser.add_argument("--cli", action="store_true", help="Install the Smart CLI")
+    parser.add_argument("--backend", action="store_true", help="Install the Backend Servers")
+    parser.add_argument("--air", action="store_true", help="Install the Air Engine")
+    
+    # Maintenance Commands
+    parser.add_argument("--repair", action="store_true", help="Check and repair LMMs installation")
+    parser.add_argument("--rebuild", action="store_true", help="Rebuild indexes and caches")
+    parser.add_argument("--factory-reset", action="store_true", help="Reset entire LMMs environment")
+
+    subparsers = parser.add_subparsers(dest="command", help="Available commands")
+    subparsers.add_parser("detect", help="Detect hardware and software specs")
+    subparsers.add_parser("compatibility", help="Show compatibility report")
+    subparsers.add_parser("doctor", help="Check missing dependencies")
+    subparsers.add_parser("benchmark", help="Estimate hardware performance")
+    
+    # Support 'autoset' as a subcommand too for convenience
+    autoset_parser = subparsers.add_parser("autoset", help="Run the fully automated install workflow")
+    autoset_parser.add_argument("--all", action="store_true")
+    autoset_parser.add_argument("--engine", action="store_true")
+    autoset_parser.add_argument("--gui", action="store_true")
+    autoset_parser.add_argument("--cli", action="store_true")
+    autoset_parser.add_argument("--backend", action="store_true")
+    autoset_parser.add_argument("--air", action="store_true")
+    
+    args = parser.parse_args()
+    
+    if args.repair:
+        reporter.print_step("Running Installation Repair...")
+        reporter.print_error("Repair Module: Coming Soon.")
+        return
+        
+    if args.rebuild:
+        reporter.print_step("Rebuilding Caches & Indexes...")
+        reporter.print_error("Rebuild Module: Coming Soon.")
+        return
+        
+    if args.factory_reset:
+        reporter.print_step("Factory Resetting LMMs Environment...")
+        reporter.print_error("Factory Reset Module: Coming Soon.")
+        return
+
+    # Gather components to install
+    components = {
+        "all": args.all,
+        "engine": args.engine,
+        "gui": args.gui,
+        "cli": args.cli,
+        "backend": args.backend,
+        "air": args.air
+    }
+
+    if args.autoset or args.command == "autoset":
+        # If no flags passed, assume 'all' for standard autoset behavior
+        if not any(components.values()):
+            components["all"] = True
+        autoset.run_autoset(components)
+        return
+        
+    if args.command == "detect":
+        hw = hardware.detect_all()
+        reporter.print_hardware_report(hw)
+        
+    elif args.command == "compatibility":
+        hw = hardware.detect_all()
+        reporter.print_compatibility_report(hw)
+        
+    elif args.command == "benchmark":
+        hw = hardware.detect_all()
+        reporter.print_benchmark_estimate(hw)
+        
+    elif args.command == "doctor":
+        hw = hardware.detect_all()
+        reporter.print_step("Running LMMs Builder Doctor...")
+        reporter.print_hardware_report(hw)
+        if hw['os']['system'] not in ['Linux', 'Windows', 'Darwin']:
+            reporter.print_error("Unsupported OS detected.")
+        else:
+            reporter.print_success("OS Supported.")
+            
+        if hw['ram']['total_gb'] < 8:
+            reporter.print_error("LMMs requires at least 8GB of RAM.")
+        else:
+            reporter.print_success("Sufficient RAM detected.")
+            
+    else:
+        parser.print_help()
+
+if __name__ == "__main__":
+    main()

lmms_builder/hardware.py

@@ -0,0 +1,88 @@
+import os
+import platform
+import psutil
+import subprocess
+
+def detect_os():
+    return {
+        "system": platform.system(),
+        "release": platform.release(),
+        "architecture": platform.machine(),
+    }
+
+def detect_cpu():
+    return {
+        "cores": psutil.cpu_count(logical=False),
+        "threads": psutil.cpu_count(logical=True),
+    }
+
+def detect_ram():
+    mem = psutil.virtual_memory()
+    return {
+        "total_gb": round(mem.total / (1024**3), 2),
+        "available_gb": round(mem.available / (1024**3), 2)
+    }
+
+def detect_gpu():
+    try:
+        # Check nvidia-smi
+        result = subprocess.run(
+            ["nvidia-smi", "--query-gpu=name,memory.total", "--format=csv,noheader"],
+            capture_output=True, text=True, check=True
+        )
+        lines = result.stdout.strip().split("\n")
+        if lines and lines[0]:
+            parts = lines[0].split(",")
+            name = parts[0].strip()
+            vram_str = parts[1].strip()
+            vram_mb = int(vram_str.replace(" MiB", ""))
+            return {
+                "detected": True,
+                "name": name,
+                "vram_gb": round(vram_mb / 1024, 2),
+                "type": "nvidia"
+            }
+    except (FileNotFoundError, subprocess.CalledProcessError):
+        pass
+        
+    return {
+        "detected": False,
+        "name": "None",
+        "vram_gb": 0.0,
+        "type": "none"
+    }
+
+def detect_cuda():
+    try:
+        result = subprocess.run(["nvcc", "--version"], capture_output=True, text=True, check=True)
+        for line in result.stdout.split("\n"):
+            if "release" in line:
+                version = line.split("release")[1].strip().split(",")[0]
+                return {"available": True, "version": version}
+    except (FileNotFoundError, subprocess.CalledProcessError):
+        pass
+        
+    try:
+        result = subprocess.run(["nvidia-smi"], capture_output=True, text=True, check=True)
+        if "CUDA Version: " in result.stdout:
+            version = result.stdout.split("CUDA Version: ")[1].split(" ")[0]
+            return {"available": True, "version": version}
+    except (FileNotFoundError, subprocess.CalledProcessError):
+        pass
+
+    return {"available": False, "version": None}
+
+def detect_python():
+    return {
+        "version": platform.python_version()
+    }
+
+def detect_all():
+    return {
+        "os": detect_os(),
+        "cpu": detect_cpu(),
+        "ram": detect_ram(),
+        "gpu": detect_gpu(),
+        "cuda": detect_cuda(),
+        "python": detect_python()
+    }

lmms_builder/installer.py

@@ -0,0 +1,137 @@
+import subprocess
+import sys
+import json
+import os
+import platform
+import requests
+from pathlib import Path
+from rich.progress import Progress, TextColumn, BarColumn, DownloadColumn, TransferSpeedColumn, TimeRemainingColumn
+from . import reporter
+
+def check_python_version():
+    return sys.version_info >= (3, 9)
+
+def ensure_base_tools():
+    # Only useful if we still use pip for other components
+    return True
+
+def get_registry_path():
+    p = Path(os.path.expanduser("~/.lmms/config/installed_components.json"))
+    p.parent.mkdir(parents=True, exist_ok=True)
+    return p
+
+def get_installed_components():
+    reg = get_registry_path()
+    if reg.exists():
+        try:
+            with open(reg, "r") as f:
+                return json.load(f)
+        except:
+            pass
+    return {}
+
+def mark_installed(component):
+    installed = get_installed_components()
+    installed[component] = True
+    with open(get_registry_path(), "w") as f:
+        json.dump(installed, f)
+
+def download_engine_binary():
+    # Detect OS
+    system = platform.system().lower()
+    machine = platform.machine().lower()
+    
+    # Construct binary name
+    if system == "windows":
+        binary_name = "lmms-engine-windows-amd64.exe"
+    elif system == "linux":
+        binary_name = "lmms-engine-linux-amd64"
+    elif system == "darwin": # macOS
+        binary_name = "lmms-engine-darwin-amd64"
+    else:
+        reporter.print_error(f"Unsupported OS for binary download: {system}")
+        return False
+
+    # Define Download URL (GitHub Releases)
+    # Using the official MarkanM GitHub release URL format
+    repo_url = "https://github.com/MarkanM-Official/LMMs-engine/releases/latest/download"
+    download_url = f"{repo_url}/{binary_name}"
+    
+    # Define Install Path
+    if system == "windows":
+        install_dir = Path(os.path.expandvars("%LOCALAPPDATA%")) / "LMMs" / "bin"
+        install_path = install_dir / "lmms.exe"
+    else:
+        # Default Linux/Mac path
+        install_dir = Path("/usr/local/bin")
+        install_path = install_dir / "lmms"
+        
+        # Fallback if no sudo permissions
+        if not os.access(install_dir, os.W_OK):
+            install_dir = Path.home() / ".local" / "bin"
+            install_path = install_dir / "lmms"
+            
+    install_dir.mkdir(parents=True, exist_ok=True)
+    
+    reporter.print_step(f"Downloading compiled engine from GitHub Releases...")
+    
+    try:
+        response = requests.get(download_url, stream=True)
+        response.raise_for_status()
+        total_size = int(response.headers.get('content-length', 0))
+        
+        with Progress(
+            TextColumn("[bold cyan]{task.description}"),
+            BarColumn(bar_width=40),
+            "[progress.percentage]{task.percentage:>3.1f}%",
+            "•",
+            DownloadColumn(),
+            "•",
+            TransferSpeedColumn(),
+            "•",
+            TimeRemainingColumn(),
+            console=reporter.console
+        ) as progress:
+            task = progress.add_task("Downloading Engine...", total=total_size)
+            with open(install_path, "wb") as file:
+                for chunk in response.iter_content(chunk_size=8192):
+                    if chunk:
+                        file.write(chunk)
+                        progress.update(task, advance=len(chunk))
+        
+        if system != "windows":
+            # Make executable
+            os.chmod(install_path, 0o755)
+        reporter.print_success(f"✓ Binary installed to {install_path}")
+        return True
+    except requests.exceptions.HTTPError as e:
+        if e.response.status_code == 404:
+            reporter.print_error(f"Download Error: Binary not found on GitHub (404).")
+            reporter.print_error("Please upload the compiled binary to your GitHub Releases first!")
+        else:
+            reporter.print_error(f"HTTP Error: {e}")
+        return False
+    except Exception as e:
+        reporter.print_error(f"Download failed: {e}")
+        return False
+
+def install_component(component_name):
+    installed = get_installed_components()
+    if installed.get(component_name):
+        reporter.print_success(f"✓ {component_name.capitalize()} is already installed. Skipping.")
+        return True, ""
+
+    if component_name != "engine":
+        reporter.print_error(f"🚀 {component_name.capitalize()} Module: Coming Soon (Development in progress).")
+        return True, ""
+
+    reporter.print_step(f"Installing {component_name.capitalize()} (Compiled Binary)...")
+    
+    success = download_engine_binary()
+    
+    if success:
+        mark_installed(component_name)
+        reporter.print_success(f"✓ {component_name.capitalize()} installed successfully.")
+        return True, ""
+    else:
+        return False, "Binary download failed"

lmms_builder/reporter.py

@@ -0,0 +1,93 @@
+from rich.console import Console
+from rich.table import Table
+from rich.panel import Panel
+
+console = Console()
+
+def print_header():
+    console.print(Panel("[bold cyan]LMMs Builder[/bold cyan]\n[bold yellow]LMMs Powerd by MarkanM[/bold yellow]\n[dim]Bootstrapper & Hardware Profiler[/dim]", border_style="cyan"))
+
+def print_hardware_report(hw):
+    table = Table(title="Hardware Detection Report", show_header=True, header_style="bold magenta")
+    table.add_column("Component", style="cyan")
+    table.add_column("Details", style="green")
+    
+    os_info = f"{hw['os']['system']} {hw['os']['release']} ({hw['os']['architecture']})"
+    table.add_row("OS", os_info)
+    
+    cpu_info = f"{hw['cpu']['cores']} Cores / {hw['cpu']['threads']} Threads"
+    table.add_row("CPU", cpu_info)
+    
+    ram_info = f"{hw['ram']['total_gb']} GB (Available: {hw['ram']['available_gb']} GB)"
+    table.add_row("RAM", ram_info)
+    
+    if hw['gpu']['detected']:
+        gpu_info = f"{hw['gpu']['name']} ({hw['gpu']['vram_gb']} GB VRAM)"
+    else:
+        gpu_info = "None Detected"
+    table.add_row("GPU", gpu_info)
+    
+    if hw['cuda']['available']:
+        cuda_info = f"Version {hw['cuda']['version']}"
+    else:
+        cuda_info = "Not Available"
+    table.add_row("CUDA", cuda_info)
+    
+    table.add_row("Python", hw['python']['version'])
+    
+    console.print(table)
+
+def print_compatibility_report(hw):
+    console.print("\n[bold magenta]========================[/bold magenta]")
+    console.print("[bold cyan]LMMS Compatibility[/bold cyan]\n")
+    
+    engine_comp = 100
+    cli_comp = 100
+    gui_comp = 100
+    air_comp = 100 if hw['ram']['total_gb'] >= 16 else 50
+    vllm_comp = 100 if hw['gpu']['detected'] and hw['gpu']['vram_gb'] >= 8 else 0
+    
+    console.print(f"Engine: {engine_comp}%")
+    console.print(f"CLI: {cli_comp}%")
+    console.print(f"GUI: {gui_comp}%")
+    console.print(f"Air Engine: {air_comp}%")
+    console.print(f"vLLM: {vllm_comp}%")
+    
+    overall = (engine_comp + cli_comp + gui_comp + air_comp + vllm_comp) // 5
+    console.print(f"\n[bold green]Overall: {overall}%[/bold green]")
+    console.print("[bold magenta]========================[/bold magenta]\n")
+
+def print_benchmark_estimate(hw):
+    console.print("\n[bold cyan]Hardware Benchmark (Estimated)[/bold cyan]")
+    
+    # Calculate an estimated TPS multiplier based on hardware
+    base = 5.0
+    if hw['gpu']['detected']:
+        base += hw['gpu']['vram_gb'] * 2
+    else:
+        base += hw['cpu']['cores'] * 1.5
+        
+    console.print("llama.cpp (7B): ~[green]{:.1f} tok/s[/green]".format(base))
+    console.print("ollama (7B): ~[green]{:.1f} tok/s[/green]".format(base * 0.95))
+    if hw['ram']['total_gb'] >= 16:
+        console.print("air (70B): ~[yellow]{:.1f} tok/s[/yellow]".format(max(1.0, base / 10)))
+    else:
+        console.print("air (70B): [red]Not Recommended (Insufficent RAM)[/red]")
+        
+def print_step(step_msg):
+    console.print(f"[bold blue]>[/bold blue] {step_msg}")
+
+def print_success(msg):
+    console.print(f"[bold green]✓[/bold green] {msg}")
+
+def print_error(msg):
+    console.print(f"[bold red]✗[/bold red] {msg}")
+
+def print_autoset_summary(mode, runtime):
+    console.print(Panel(
+        f"[bold green]AutoSet Complete![/bold green]\n\n"
+        f"[cyan]Default Mode:[/cyan] {mode}\n"
+        f"[cyan]Default Runtime:[/cyan] {runtime}\n\n"
+        "Run [bold magenta]lmms[/bold magenta] to launch.",
+        border_style="green"
+    ))

lmms_builder-1.0.0.dist-info/METADATA

@@ -0,0 +1,11 @@
+Metadata-Version: 2.4
+Name: lmms-builder
+Version: 1.0.0
+Summary: Bootstrapper for the LMMs OS
+Requires-Python: >=3.9
+Requires-Dist: psutil
+Requires-Dist: rich
+Requires-Dist: requests
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary

lmms_builder-1.0.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+lmms_builder/__init__.py,sha256=s4WXUCdtZenBWJdOJj8FZE-SsdNjqm_9x6igsTb_quM,52
+lmms_builder/autoset.py,sha256=zIj8wHhO5Z-ufS8xoKowVbAwNaMddhnossMnxh_u_g0,2867
+lmms_builder/bootstrap.py,sha256=FCKKncqovq9Ir1Guka4fHI6HOmPp_fgRCfXB508a718,1183
+lmms_builder/cli.py,sha256=NfaPJGeH7C9KrXxd8mhhPYwg_aFdImANrGzjHlubn_Q,4215
+lmms_builder/hardware.py,sha256=ZYZ7XJejbx2j2UBfilEPpsJ7XdiRuRXgWnGac7dJMGc,2560
+lmms_builder/installer.py,sha256=nglj_ALkVAK9becn5UOByVMND5zyJ7tDSJorhJSxQ0s,4793
+lmms_builder/reporter.py,sha256=V4pHTZwOEWZ1MrVoA9L_DAxIx-WRl8wgMRAsxn7IOH4,3480
+lmms_builder-1.0.0.dist-info/METADATA,sha256=RLCZtY2P6ywkEUDmP66uFdaueExM8CfWKaNpPi61F98,248
+lmms_builder-1.0.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+lmms_builder-1.0.0.dist-info/entry_points.txt,sha256=rizkh_pFUAyrWYLAOS3EU6ArUif0Qt8-8nPJzL5jeqM,55
+lmms_builder-1.0.0.dist-info/top_level.txt,sha256=CvyaNnnSTryMQZoYWbnMFuzmbwXLwjS8KWanpLg0kl0,13
+lmms_builder-1.0.0.dist-info/RECORD,,

lmms_builder-1.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

lmms_builder-1.0.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+lmms-builder = lmms_builder.cli:main

lmms_builder-1.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+lmms_builder