ltcai 11.5.2 → 11.7.0

package/latticeai/setup/wizard/paths.py

@@ -1,165 +0,0 @@
-"""PATH discovery, binary lookup, and the ``.env`` handoff for the wizard.
-
-The base layer of the setup wizard: it knows where installers put things on
-each platform, how to get those directories onto ``PATH`` for the running
-process, and how to persist that repair into the project ``.env``. Nothing
-here imports another wizard submodule, which is also what lets
-``tests/unit/test_cov_wp04_wizard_detect.py`` re-execute this file under a
-throwaway name to reach the Windows-only import-time branch.
-
-``COMMON_PATH_DIRS`` is module-level state that the import-time Windows block
-extends and tests replace, so it lives here and only here — the modules that
-repair PATH call :func:`repair_path_for` rather than copying the list.
-"""
-
-from __future__ import annotations
-
-import os
-import platform
-import shutil
-from pathlib import Path
-from typing import Any, Dict, List
-
-from latticeai.core.module_probe import module_available as _module_available
-
-OFFICIAL_DOWNLOADS: Dict[str, str] = {
-    "homebrew": "https://brew.sh",
-    "python": "https://www.python.org/downloads/",
-    "node": "https://nodejs.org/en/download",
-    "git": "https://git-scm.com/downloads",
-    "ollama": "https://ollama.com/download",
-    "lmstudio": "https://lmstudio.ai/download",
-    "cuda": "https://developer.nvidia.com/cuda-downloads",
-    "mlx": "https://ml-explore.github.io/mlx/build/html/install.html",
-    "cloudflared": "https://developers.cloudflare.com/cloudflare-one/connections/connect-networks/downloads/",
-    "tesseract": "https://tesseract-ocr.github.io/tessdoc/Installation.html",
-}
-
-COMMON_PATH_DIRS = [
-    "/opt/homebrew/bin",
-    "/usr/local/bin",
-    "/usr/bin",
-    "/bin",
-    str(Path.home() / ".local" / "bin"),
-    str(Path.home() / ".cargo" / "bin"),
-    str(Path.home() / ".latticeai" / "bin"),
-]
-
-if platform.system() == "Windows":
-    _local_appdata = os.environ.get("LOCALAPPDATA", "")
-    _program_files = os.environ.get("ProgramFiles", r"C:\Program Files")
-    _program_files_x86 = os.environ.get("ProgramFiles(x86)", r"C:\Program Files (x86)")
-    COMMON_PATH_DIRS.extend([
-        str(Path(_local_appdata) / "Programs" / "Ollama") if _local_appdata else "",
-        str(Path(_program_files) / "Ollama"),
-        str(Path(_program_files) / "LM Studio"),
-        str(Path(_program_files) / "NVIDIA Corporation" / "NVSMI"),
-        str(Path(_program_files_x86) / "NVIDIA Corporation" / "NVSMI"),
-    ])
-    COMMON_PATH_DIRS = [p for p in COMMON_PATH_DIRS if p]
-
-WINDOWS_BINARY_CANDIDATES: Dict[str, List[str]] = {
-    "ollama": [
-        str(Path(os.environ.get("LOCALAPPDATA", "")) / "Programs" / "Ollama" / "ollama.exe"),
-        str(Path(os.environ.get("ProgramFiles", r"C:\Program Files")) / "Ollama" / "ollama.exe"),
-    ],
-    "lms": [
-        str(Path(os.environ.get("LOCALAPPDATA", "")) / "Programs" / "LM Studio" / "resources" / "app" / ".webpack" / "lms.exe"),
-        str(Path(os.environ.get("ProgramFiles", r"C:\Program Files")) / "LM Studio" / "resources" / "app" / ".webpack" / "lms.exe"),
-    ],
-    "nvidia-smi": [
-        str(Path(os.environ.get("ProgramFiles", r"C:\Program Files")) / "NVIDIA Corporation" / "NVSMI" / "nvidia-smi.exe"),
-        str(Path(os.environ.get("ProgramFiles(x86)", r"C:\Program Files (x86)")) / "NVIDIA Corporation" / "NVSMI" / "nvidia-smi.exe"),
-    ],
-}
-
-PACKAGE_MODULES: Dict[str, str] = {
-    "mlx-vlm": "mlx_vlm",
-    "huggingface_hub[cli]": "huggingface_hub",
-    "openai-whisper": "whisper",
-}
-
-
-def _project_env_file() -> Path:
-    return Path(__file__).resolve().parents[2] / ".env"
-
-
-def _update_env_file(env_file: Path, key: str, value: str) -> None:
-    lines: List[str] = []
-    found = False
-    if env_file.exists():
-        lines = env_file.read_text(encoding="utf-8").splitlines()
-    updated: List[str] = []
-    for line in lines:
-        if line.startswith(f"{key}="):
-            updated.append(f"{key}={value}")
-            found = True
-        else:
-            updated.append(line)
-    if not found:
-        updated.append(f"{key}={value}")
-    env_file.write_text("\n".join(updated) + "\n", encoding="utf-8")
-
-
-def _merge_path_dirs(dirs: List[str]) -> List[str]:
-    current = os.environ.get("PATH", "")
-    parts = [p for p in current.split(os.pathsep) if p]
-    for item in dirs:
-        expanded = str(Path(item).expanduser())
-        if Path(expanded).exists() and expanded not in parts:
-            parts.insert(0, expanded)
-    os.environ["PATH"] = os.pathsep.join(parts)
-    return parts
-
-
-def _persist_extra_path(dirs: List[str]) -> None:
-    existing = [
-        p for p in os.environ.get("LATTICEAI_EXTRA_PATH", "").split(os.pathsep)
-        if p
-    ]
-    merged = existing[:]
-    for item in dirs:
-        expanded = str(Path(item).expanduser())
-        if Path(expanded).exists() and expanded not in merged:
-            merged.append(expanded)
-    if merged:
-        os.environ["LATTICEAI_EXTRA_PATH"] = os.pathsep.join(merged)
-        _update_env_file(_project_env_file(), "LATTICEAI_EXTRA_PATH", os.environ["LATTICEAI_EXTRA_PATH"])
-
-
-def repair_path_for(binary: str | None = None) -> List[str]:
-    before = _which_any(binary) if binary else None
-    paths = _merge_path_dirs(COMMON_PATH_DIRS)
-    if binary and not before and _which_any(binary):
-        _persist_extra_path(COMMON_PATH_DIRS)
-    return paths
-
-
-def _which_any(binary: str) -> str | None:
-    path = shutil.which(binary)
-    if path:
-        return path
-    if platform.system() == "Windows":
-        for candidate in WINDOWS_BINARY_CANDIDATES.get(binary, []):
-            if candidate and Path(candidate).exists():
-                return candidate
-    return None
-
-
-def _which_detail(binary: str) -> Dict[str, Any]:
-    path = _which_any(binary)
-    return {"installed": path is not None, "path": path}
-
-
-def _package_module(package: str) -> str:
-    return PACKAGE_MODULES.get(package, package.replace("-", "_").split("[", 1)[0])
-
-
-def _component_detail(name: str, binary: str | None = None, module: str | None = None) -> Dict[str, Any]:
-    detail: Dict[str, Any] = {"official_url": OFFICIAL_DOWNLOADS.get(name)}
-    if binary:
-        detail.update(_which_detail(binary))
-    if module:
-        detail["module_available"] = _module_available(module)
-        detail["installed"] = bool(detail.get("installed") or detail["module_available"])
-    return detail

package/latticeai/setup/wizard/plans.py

@@ -1,74 +0,0 @@
-"""SSE framing and the confirmation-token plans for wizard install actions.
-
-Every install action the wizard offers is turned into an explicit command plan
-before it is shown, so the token the browser sends back can be compared against
-the exact commands that would run. An action with nothing to execute has no
-plan and therefore nothing to confirm.
-"""
-
-from __future__ import annotations
-
-import sys
-from typing import Any, Dict, List
-
-from latticeai.core.sse import sse_frame
-from latticeai.services.process_audit import command_plan_for_commands
-
-
-def _sse(data: Dict) -> str:
-    return sse_frame(None, data)
-
-
-def _action_commands(action: Dict[str, Any]) -> List[List[str]]:
-    atype = action.get("type")
-    if atype == "pip":
-        return [[sys.executable, "-m", "pip", "install", "--upgrade", str(pkg)] for pkg in action.get("packages", [])]
-    if atype == "brew":
-        package = str(action.get("package") or "")
-        return [["brew", "install", package]] if package else []
-    return []
-
-
-def _action_command_plan(action: Dict[str, Any], *, name: str) -> Dict[str, Any] | None:
-    commands = _action_commands(action)
-    if not commands:
-        return None
-    return command_plan_for_commands(
-        commands,
-        name=name,
-        purpose="setup_wizard_install",
-        metadata={"action_type": action.get("type")},
-    )
-
-
-def _attach_action_plan(action: Dict[str, Any] | None, *, name: str) -> Dict[str, Any] | None:
-    if not isinstance(action, dict):
-        return action
-    plan = _action_command_plan(action, name=name)
-    if not plan:
-        return action
-    hydrated = dict(action)
-    hydrated["command_plan"] = plan
-    hydrated["confirmation_token"] = plan["confirmation_token"]
-    return hydrated
-
-
-def _hydrate_install_actions(groups: Dict[str, Any]) -> Dict[str, Any]:
-    for group_name in ("components", "engines", "models", "mcps"):
-        items = groups.get(group_name)
-        if not isinstance(items, list):
-            continue
-        for item in items:
-            if isinstance(item, dict):
-                item["action"] = _attach_action_plan(
-                    item.get("action"),
-                    name=str(item.get("id") or item.get("name") or group_name),
-                )
-    return groups
-
-
-def _verify_action_confirmation(action: Dict[str, Any], token: str | None, *, name: str) -> bool:
-    plan = _action_command_plan(action, name=name)
-    if not plan:
-        return True
-    return str(token or "").strip() == plan["confirmation_token"]

package/latticeai/setup/wizard/recommend.py

@@ -1,320 +0,0 @@
-"""The wizard's recommendation: environment scan in, tailored checklist out.
-
-Pure function over the :func:`~latticeai.setup.wizard.detect.scan_environment`
-payload — no probing, no installing. It picks the preferred engine, filters the
-catalogue to what fits, and returns the component / engine / model / MCP groups
-the setup screen renders, each already carrying a confirmation-token plan.
-"""
-
-from __future__ import annotations
-
-import sys
-from typing import Any, Dict, List
-
-from latticeai.setup.wizard.catalog import (
-    _CROSS_PLATFORM_MODEL_CATALOG,
-    _MODEL_CATALOG,
-    _best_model_for_engine,
-    _filter_lower_family_versions,
-)
-from latticeai.setup.wizard.paths import OFFICIAL_DOWNLOADS
-from latticeai.setup.wizard.plans import _hydrate_install_actions
-
-# ── Recommendation Logic ──────────────────────────────────────────────────────
-
-def get_recommendations(env: Dict[str, Any]) -> Dict[str, Any]:
-    ram       = env["ram_gb"]
-    chip      = env["chip"]
-    mlx       = env["mlx"]
-    tools     = env["tools"]
-    api_keys  = env["api_keys"]
-    disk_free = env["disk_free_gb"]
-    is_apple  = chip["is_apple_silicon"]
-    gpu       = env.get("gpu", {})
-    cuda      = env.get("cuda", {})
-    wsl       = env.get("wsl", {})
-    cpu       = env.get("cpu", {})
-    os_name   = env.get("os", "")
-
-    max_model_gb = ram * 0.72  # ~28% headroom for OS + apps
-
-    if is_apple:
-        preferred_engine = "local_mlx"
-    elif gpu.get("vendor") == "nvidia" and cuda.get("available") and (os_name == "Linux" or wsl.get("is_wsl")):
-        preferred_engine = "vllm"
-    elif tools.get("lms"):
-        preferred_engine = "lmstudio"
-    elif tools.get("ollama"):
-        preferred_engine = "ollama"
-    else:
-        preferred_engine = "llamacpp"
-
-    apple_catalog = _filter_lower_family_versions(_MODEL_CATALOG)
-    engine_catalog = (
-        []
-        if is_apple
-        else _filter_lower_family_versions(_CROSS_PLATFORM_MODEL_CATALOG[preferred_engine])
-    )
-    best_id = _best_model_for_engine(
-        "local_mlx" if is_apple else preferred_engine,
-        ram,
-        apple_catalog if is_apple else engine_catalog,
-    )
-
-    # ── Engines ──────────────────────────────────────────────────────────────
-    engines: List[Dict] = []
-
-    if is_apple:
-        if mlx["available"] and mlx["mlx_vlm"]:
-            engines.append({
-                "id": "engine_mlx", "name": "MLX",
-                "subtitle": f"{chip['name']} GPU 가속 · MLX-VLM 멀티모달 실행",
-                "status": "installed", "priority": "recommended",
-                "checked": True, "action": None, "badge": "설치됨",
-            })
-        else:
-            engines.append({
-                "id": "engine_mlx", "name": "MLX",
-                "subtitle": f"{chip['name']} 전용 MLX-VLM 멀티모달 실행",
-                "status": "available", "priority": "recommended",
-                "checked": True,
-                "action": {"type": "pip", "packages": ["mlx-vlm"], "verify_modules": ["mlx", "mlx_vlm"]},
-                "badge": "설치 필요",
-            })
-
-    if tools.get("ollama"):
-        engines.append({
-            "id": "engine_ollama", "name": "Ollama",
-            "subtitle": "범용 로컬 LLM 서버 · 크로스 플랫폼",
-            "status": "installed", "priority": "recommended" if preferred_engine == "ollama" else "optional",
-            "checked": preferred_engine == "ollama", "action": None, "badge": "설치됨",
-        })
-    else:
-        hint = "brew install 가능" if (tools.get("brew") or env["os"] == "Darwin") else "수동 설치 필요"
-        engines.append({
-            "id": "engine_ollama", "name": "Ollama",
-            "subtitle": "범용 로컬 LLM 서버 · 크로스 플랫폼",
-            "status": "available", "priority": "recommended" if preferred_engine == "ollama" else "optional",
-            "checked": preferred_engine == "ollama",
-            "action": (
-                {"type": "brew", "package": "ollama", "binary": "ollama", "official_url": OFFICIAL_DOWNLOADS["ollama"]}
-                if tools.get("brew")
-                else {"type": "url", "url": OFFICIAL_DOWNLOADS["ollama"], "binary": "ollama"}
-            ),
-            "badge": hint,
-        })
-
-    if not is_apple:
-        lmstudio_installed = bool(tools.get("lms"))
-        engines.append({
-            "id": "engine_lmstudio", "name": "LM Studio",
-            "subtitle": "Windows/macOS/Linux 데스크톱 GPU 서버 · 모델 다운로드 UI 포함",
-            "status": "installed" if lmstudio_installed else "available",
-            "priority": "recommended" if preferred_engine == "lmstudio" else "optional",
-            "checked": preferred_engine == "lmstudio",
-            "action": None if lmstudio_installed else {"type": "url", "url": OFFICIAL_DOWNLOADS["lmstudio"], "binary": "lms"},
-            "badge": "설치됨" if lmstudio_installed else "설치 필요",
-        })
-        if gpu.get("vendor") == "nvidia":
-            engines.append({
-                "id": "engine_cuda", "name": "CUDA",
-                "subtitle": f"NVIDIA {gpu.get('name') or 'GPU'} · VRAM {gpu.get('vram_gb') or 0} GB",
-                "status": "installed" if cuda.get("available") else "available",
-                "priority": "recommended",
-                "checked": False,
-                "action": None if cuda.get("available") else {"type": "url", "url": OFFICIAL_DOWNLOADS["cuda"], "binary": "nvcc"},
-                "badge": cuda.get("version") or ("감지됨" if cuda.get("available") else "설치 필요"),
-            })
-            engines.append({
-                "id": "engine_vllm", "name": "vLLM",
-                "subtitle": "NVIDIA 서버형 추론 · Windows는 WSL/Linux 권장",
-                "status": "available",
-                "priority": "recommended" if preferred_engine == "vllm" else "optional",
-                "checked": preferred_engine == "vllm",
-                "action": {"type": "pip", "packages": ["vllm", "huggingface_hub[cli]"], "verify_modules": ["vllm", "huggingface_hub"]},
-                "badge": "WSL/Linux 권장" if os_name == "Windows" and not wsl.get("is_wsl") else "설치 가능",
-            })
-        elif gpu.get("vendor") in {"amd", "intel"}:
-            engines.append({
-                "id": "engine_vulkan_directml", "name": "Vulkan/DirectML",
-                "subtitle": f"{gpu.get('vendor', '').upper()} GPU 감지 · LM Studio 또는 llama.cpp 백엔드 권장",
-                "status": "available",
-                "priority": "recommended" if preferred_engine in {"lmstudio", "llamacpp"} else "optional",
-                "checked": False,
-                "action": None,
-                "badge": gpu.get("backend") or "GPU",
-            })
-
-    components: List[Dict] = []
-    component_specs = [
-        ("homebrew", "Homebrew", "macOS 패키지 관리자 · 자동 설치 기반", "brew", None, "recommended"),
-        ("git", "Git", "저장소 · 확장 · MCP 도구 연동에 필요", "git", "git", "recommended"),
-        ("node", "Node.js", "npm 패키지와 VS Code 확장 개발에 필요", "node", "node", "optional"),
-        ("tesseract", "Tesseract OCR", "이미지/PDF OCR 기능에 필요", "tesseract", "tesseract", "optional"),
-    ]
-    for cid, name, subtitle, binary, brew_pkg, priority in component_specs:
-        installed = bool(tools.get(binary))
-        if cid == "homebrew" and env["os"] != "Darwin":
-            continue
-        if installed:
-            components.append({
-                "id": f"component_{cid}", "name": name,
-                "subtitle": subtitle, "status": "installed",
-                "priority": priority, "checked": False, "action": None,
-                "badge": "설치됨",
-            })
-            continue
-        if cid == "homebrew":
-            action = {"type": "url", "url": OFFICIAL_DOWNLOADS["homebrew"], "binary": "brew"}
-        elif tools.get("brew") and brew_pkg:
-            action = {
-                "type": "brew",
-                "package": brew_pkg,
-                "binary": binary or "",
-                "official_url": OFFICIAL_DOWNLOADS.get(cid, ""),
-            }
-        else:
-            action = {
-                "type": "url",
-                "url": OFFICIAL_DOWNLOADS.get(cid, ""),
-                "binary": binary or "",
-            }
-        components.append({
-            "id": f"component_{cid}", "name": name,
-            "subtitle": subtitle, "status": "available",
-            "priority": priority, "checked": priority == "recommended",
-            "action": action, "badge": "설치 필요",
-        })
-
-    python_ok = sys.version_info >= (3, 11)
-    if not python_ok:
-        components.insert(0, {
-            "id": "component_python", "name": "Python 3.11+",
-            "subtitle": "Lattice AI 서버 실행에 필요한 Python 런타임",
-            "status": "available", "priority": "recommended", "checked": True,
-            "action": {"type": "url", "url": OFFICIAL_DOWNLOADS["python"], "binary": "python3"},
-            "badge": "업데이트 필요",
-        })
-
-    for provider, has_key in api_keys.items():
-        if has_key:
-            engines.append({
-                "id": f"engine_{provider}", "name": provider.title(),
-                "subtitle": f"{provider.upper()}_API_KEY 감지됨 · 클라우드 API",
-                "status": "ready", "priority": "optional",
-                "checked": False, "action": None, "badge": "준비됨",
-            })
-
-    # ── Models ───────────────────────────────────────────────────────────────
-    models: List[Dict] = []
-
-    if is_apple:
-        for mid, mname, size_gb, tag, desc, min_ram in apple_catalog:
-            fits    = ram >= min_ram and size_gb <= max_model_gb and disk_free >= size_gb + 2
-            is_best = mid == best_id
-            models.append({
-                "id":       f"model_{mid.replace('/', '__').replace('-', '_')}",
-                "model_id": mid,
-                "name":     mname,
-                "subtitle": desc,
-                "size_gb":  size_gb,
-                "tag":      tag,
-                "fits":     fits,
-                "priority": "recommended" if is_best else "optional",
-                "checked":  is_best and fits,
-                "disabled": not fits,
-                "badge":    f"{size_gb} GB",
-                "action":   {"type": "load_model", "model_id": mid} if fits else None,
-            })
-    else:
-        vram_gb = float(gpu.get("vram_gb") or 0)
-        gpu_budget_gb = vram_gb * 1.15 if gpu.get("vendor") in {"nvidia", "amd", "intel"} and vram_gb else max_model_gb
-        model_budget_gb = min(max_model_gb, gpu_budget_gb)
-        for mid, mname, size_gb, tag, desc, min_ram in engine_catalog:
-            fits = ram >= min_ram and size_gb <= model_budget_gb and disk_free >= size_gb + 2
-            is_best = mid == best_id
-            models.append({
-                "id":       f"model_{mid.replace('/', '__').replace(':', '__').replace('-', '_')}",
-                "model_id": mid,
-                "name":     mname,
-                "subtitle": desc,
-                "size_gb":  size_gb,
-                "tag":      tag,
-                "fits":     fits,
-                "priority": "recommended" if is_best else "optional",
-                "checked":  is_best and fits,
-                "disabled": not fits,
-                "badge":    f"{size_gb} GB · {preferred_engine}",
-                "action":   {"type": "load_model", "model_id": mid} if fits else None,
-            })
-    if models and not any(item.get("checked") for item in models):
-        for item in models:
-            if not item.get("disabled"):
-                item["priority"] = "recommended"
-                item["checked"] = True
-                break
-
-    # ── MCPs ─────────────────────────────────────────────────────────────────
-    mcps: List[Dict] = [
-        {
-            "id": "mcp_files", "name": "Workspace Files",
-            "subtitle": "파일 읽기/쓰기 · 코드 생성 · 미리보기",
-            "status": "active", "priority": "recommended",
-            "checked": True, "action": None,
-            "badge": "기본 탑재", "needs_auth": False,
-        },
-        {
-            "id": "mcp_presentations", "name": "Presentations",
-            "subtitle": "PPTX · 슬라이드 자동 생성",
-            "status": "active", "priority": "optional",
-            "checked": False, "action": None,
-            "badge": "기본 탑재", "needs_auth": False,
-        },
-        {
-            "id": "mcp_github", "name": "GitHub",
-            "subtitle": "저장소 · PR · 이슈 · CI 연동",
-            "status": "available", "priority": "optional",
-            "checked": False,
-            "action": {"type": "auth", "url": "https://github.com/apps", "mcp_id": "github"},
-            "badge": "인증 필요", "needs_auth": True,
-        },
-        {
-            "id": "mcp_googledrive", "name": "Google Drive",
-            "subtitle": "Docs · Sheets · Drive 파일 연동",
-            "status": "available", "priority": "optional",
-            "checked": False,
-            "action": {"type": "auth", "url": "https://chatgpt.com/connectors", "mcp_id": "google-drive"},
-            "badge": "인증 필요", "needs_auth": True,
-        },
-        {
-            "id": "mcp_slack", "name": "Slack",
-            "subtitle": "팀 채널 공유 · 알림 워크플로",
-            "status": "available", "priority": "optional",
-            "checked": False,
-            "action": {"type": "auth", "url": "https://chatgpt.com/connectors", "mcp_id": "slack"},
-            "badge": "인증 필요", "needs_auth": True,
-        },
-    ]
-
-    return _hydrate_install_actions({
-        "components": components,
-        "engines": engines,
-        "models":  models,
-        "mcps":    mcps,
-        "summary": {
-            "chip":            chip["name"],
-            "cpu_cores":       cpu.get("logical_cores"),
-            "cpu_instructions": cpu.get("instructions", []),
-            "gpu":             gpu.get("name") or gpu.get("vendor"),
-            "gpu_vendor":      gpu.get("vendor"),
-            "vram_gb":         gpu.get("vram_gb"),
-            "cuda":            cuda.get("available"),
-            "cuda_version":    cuda.get("version"),
-            "wsl":             wsl,
-            "preferred_engine": preferred_engine,
-            "ram_gb":          ram,
-            "disk_free_gb":    disk_free,
-            "is_apple_silicon": is_apple,
-            "max_model_gb":    round(max_model_gb, 1),
-        },
-    })