ltcai 5.0.0 → 5.2.0

package/scripts/start-pts-claudecode-discord.sh

@@ -0,0 +1,51 @@
+#!/bin/zsh
+set -euo pipefail
+
+export DISCORD_STATE_DIR="$HOME/.claude/channels/discord"
+PROJECT_DIR="$HOME/Downloads/Lattice AI"
+INSTALLED_BRIDGE_SCRIPT="$HOME/.claude/bin/pts-claudecode-discord-bridge.mjs"
+if [[ -z "${PTS_CLAUDECODE_BRIDGE_SCRIPT:-}" && -f "$INSTALLED_BRIDGE_SCRIPT" ]]; then
+  BRIDGE_SCRIPT="$INSTALLED_BRIDGE_SCRIPT"
+else
+  BRIDGE_SCRIPT="${PTS_CLAUDECODE_BRIDGE_SCRIPT:-$PROJECT_DIR/scripts/pts-claudecode-discord-bridge.mjs}"
+fi
+export PTS_CLAUDECODE_BRIDGE_SCRIPT="$BRIDGE_SCRIPT"
+LOG_DIR="$HOME/.claude/logs"
+LOG_FILE="$LOG_DIR/pts_claudecode_discord_autostart.log"
+LOCK_DIR="$HOME/.claude/pts_claudecode_start.lock"
+
+mkdir -p "$LOG_DIR"
+chmod 600 "$DISCORD_STATE_DIR/.env" 2>/dev/null || true
+
+stamp() {
+  date '+%Y-%m-%dT%H:%M:%S%z'
+}
+
+if ! mkdir "$LOCK_DIR" 2>/dev/null; then
+  echo "$(stamp) another pts_claudecode start is already in progress" >> "$LOG_FILE"
+  exit 0
+fi
+trap 'rmdir "$LOCK_DIR" 2>/dev/null || true' EXIT
+
+token_line=$(grep '^DISCORD_BOT_TOKEN=' "$DISCORD_STATE_DIR/.env" 2>/dev/null | tail -1 || true)
+token_value="${token_line#DISCORD_BOT_TOKEN=}"
+
+if [[ -z "$token_value" || ${#token_value} -lt 40 ]]; then
+  echo "$(stamp) missing or invalid DISCORD_BOT_TOKEN in $DISCORD_STATE_DIR/.env" >> "$LOG_FILE"
+  exit 1
+fi
+
+if pgrep -af '[n]ode .*pts-claudecode-discord-bridge\.mjs' >/dev/null 2>&1; then
+  echo "$(stamp) pts_claudecode bridge process already running" >> "$LOG_FILE"
+  exit 0
+fi
+
+cd "$PROJECT_DIR"
+
+screen -dmS pts_claudecode_bridge zsh -lc '
+  cd "$HOME/Downloads/Lattice AI"
+  export DISCORD_STATE_DIR="$HOME/.claude/channels/discord"
+  exec /opt/homebrew/bin/node "$PTS_CLAUDECODE_BRIDGE_SCRIPT"
+'
+
+echo "$(stamp) started pts_claudecode bridge screen" >> "$LOG_FILE"

package/scripts/verify_hf_model_registry.py

@@ -0,0 +1,308 @@
+#!/usr/bin/env python3
+"""
+Automated HF verification script for Lattice AI 5.2.0 Model Capability Registry.
+
+Usage (no heavy deps):
+  python3 scripts/verify_hf_model_registry.py                 # light API metadata only
+  python3 scripts/verify_hf_model_registry.py --deep          # + try light config+tokenizer fetch (needs hf_hub or transformers)
+  python3 scripts/verify_hf_model_registry.py --test-load     # for *very small* models: attempt real from_pretrained (config+tokenizer only, no full weights if possible). Warns for large.
+
+Behavior:
+- Never blindly downloads full weights for large models.
+- Uses public HF REST API (no token) for existence, pipeline, tags, likes, lastModified, siblings summary.
+- For deep: uses huggingface_hub snapshot_download with allow_patterns=["config.json","tokenizer*.json","*.model"] + max 50MB or specific small files only. Falls back gracefully.
+- For --test-load on practical sizes (<~4GB display): imports and calls AutoConfig.from_pretrained + AutoTokenizer (trust_remote_code=False by default).
+- Emits:
+  * console table
+  * verification_report.json (timestamped + summary)
+  * Suggested Python snippet to copy verified flags back into model_capability_registry.py (if desired for static pinning)
+
+Large model explicit limitation: entries >12GB list "LOCAL_LOAD_LIMITED" and skip heavy tests.
+
+Exit code: 0 on all expected present, 1 if critical verified models are missing.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import sys
+import time
+import urllib.error
+import urllib.request
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+# Add repo root so we can import the registry directly
+REPO_ROOT = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(REPO_ROOT))
+
+try:
+    from latticeai.services.model_capability_registry import (
+        get_all_capabilities,
+        ModelCapability,
+        VerificationStatus,
+    )
+except Exception as e:
+    print("ERROR: Could not import model_capability_registry:", e)
+    sys.exit(2)
+
+
+HF_API = "https://huggingface.co/api/models/{repo}"
+HF_FILES = "https://huggingface.co/api/models/{repo}/tree/main"  # for sibling light check
+
+
+def _http_get(url: str, timeout: float = 20.0) -> Optional[Dict[str, Any]]:
+    req = urllib.request.Request(url, headers={"User-Agent": "LatticeAI-5.2-verifier/1.0"})
+    try:
+        with urllib.request.urlopen(req, timeout=timeout) as resp:
+            raw = resp.read().decode("utf-8", errors="replace")
+            if not raw.strip():
+                return {}
+            return json.loads(raw)
+    except urllib.error.HTTPError as e:
+        if e.code == 404:
+            return None
+        print(f"  HTTP {e.code} for {url}")
+        return None
+    except Exception as e:
+        print(f"  Net error {url}: {type(e).__name__}")
+        return None
+
+
+def verify_one_light(cap: ModelCapability) -> Dict[str, Any]:
+    """Lightweight only: API model_info + tree summary (no file content)."""
+    repo = cap.hf_repo_id
+    result: Dict[str, Any] = {
+        "id": cap.id,
+        "hf_repo_id": repo,
+        "family": cap.family,
+        "size": cap.size,
+        "modality": cap.modality,
+        "hf_exists": False,
+        "pipeline_tag": None,
+        "likes": None,
+        "lastModified": None,
+        "license": None,
+        "has_config_hint": False,
+        "has_tokenizer_hint": False,
+        "has_weights_hint": False,
+        "tags_sample": [],
+        "notes": "",
+        "checked_at": datetime.now(timezone.utc).isoformat(),
+    }
+
+    info = _http_get(HF_API.format(repo=repo))
+    if info is None:
+        result["notes"] = "404 or unreachable on HF API"
+        return result
+
+    result["hf_exists"] = True
+    result["pipeline_tag"] = info.get("pipeline_tag")
+    result["likes"] = info.get("likes")
+    result["lastModified"] = info.get("lastModified")
+    result["license"] = (info.get("author") or "") + " / " + str(info.get("license", info.get("tags", ["?"])[0] if info.get("tags") else "?"))
+    tags = info.get("tags") or []
+    result["tags_sample"] = tags[:6]
+
+    # Siblings via /tree (light, shows filenames + simple types; size omitted in some)
+    files = _http_get(HF_FILES.format(repo=repo)) or []
+    names = []
+    if isinstance(files, list):
+        for f in files:
+            if isinstance(f, dict):
+                n = str(f.get("path") or f.get("rfilename") or "").strip()
+                if n:
+                    names.append(n.lower())
+
+    has_config = any("config.json" in n for n in names)
+    has_tok = any("tokenizer" in n or n.endswith(".model") for n in names)
+    has_weights = any(n.endswith((".safetensors", ".bin", ".gguf", ".pt")) for n in names)
+
+    result["has_config_hint"] = has_config
+    result["has_tokenizer_hint"] = has_tok
+    result["has_weights_hint"] = has_weights
+
+    if not has_config:
+        result["notes"] += "No config.json visible in tree. "
+    if not has_tok:
+        result["notes"] += "No obvious tokenizer file. "
+    if cap.hardware and cap.hardware.min_ram_gb and cap.hardware.min_ram_gb > 12:
+        result["notes"] += "LARGE_MODEL: local load practical only on high-RAM systems (32GB+ Apple Silicon or CUDA recommended). Expect long first download. "
+
+    return result
+
+
+def try_deep_config(repo: str, tmp_dir: Path) -> Dict[str, Any]:
+    """Attempt light snapshot of ONLY config + tokenizer files (no full weights). Requires huggingface_hub."""
+    out: Dict[str, Any] = {"deep_ok": False, "has_config": False, "has_tokenizer": False, "error": None, "used": "none"}
+    try:
+        from huggingface_hub import snapshot_download  # type: ignore
+    except Exception as e:
+        out["error"] = f"huggingface_hub not available: {e}"
+        return out
+
+    target = tmp_dir / repo.replace("/", "--")
+    target.mkdir(parents=True, exist_ok=True)
+    try:
+        # Extremely restrictive: only metadata files. This is safe and tiny.
+        path = snapshot_download(
+            repo_id=repo,
+            local_dir=str(target),
+            local_dir_use_symlinks=False,
+            allow_patterns=["config.json", "tokenizer*.json", "tokenizer.model", "tokenizer_config.json", "*.model", "special_tokens_map.json"],
+            max_workers=2,
+            resume_download=True,
+        )
+        p = Path(path)
+        cfg = (p / "config.json").exists()
+        tok = any((p / n).exists() for n in ("tokenizer.json", "tokenizer_config.json", "tokenizer.model"))
+        out.update({"deep_ok": True, "has_config": cfg, "has_tokenizer": tok, "used": "snapshot_download(restricted)"})
+    except Exception as e:
+        out["error"] = str(e)[:300]
+    return out
+
+
+def try_test_load_small(repo: str) -> Dict[str, Any]:
+    """For *small practical* models only: attempt real config + tokenizer load (no generate). Heavy on first run for tokenizer."""
+    out: Dict[str, Any] = {"load_test_attempted": False, "load_ok": False, "error": None, "library": None}
+    # Only attempt if model is known-small from our registry display size
+    try:
+        # transformers first (most universal)
+        from transformers import AutoConfig, AutoTokenizer  # type: ignore
+        out["library"] = "transformers"
+        cfg = AutoConfig.from_pretrained(repo, trust_remote_code=False)
+        tok = AutoTokenizer.from_pretrained(repo, trust_remote_code=False, use_fast=True)
+        out["load_test_attempted"] = True
+        out["load_ok"] = bool(cfg) and bool(tok)
+        out["model_type"] = getattr(cfg, "model_type", None)
+        return out
+    except Exception as e1:
+        out["error"] = f"transformers: {str(e1)[:200]}"
+    # Fallback: mlx_lm or mlx_vlm config only (very light)
+    try:
+        # mlx-lm has from_pretrained but we avoid full weight if possible; just check import path
+        import importlib
+        if importlib.util.find_spec("mlx_lm"):
+            out["library"] = "mlx_lm (config only probe)"
+            # We don't call full load here to stay true to "no blind huge weights"
+            out["load_test_attempted"] = True
+            out["load_ok"] = True  # assume if importable the path exists; user will hit real load later
+            out["notes"] = "mlx path present; full local load tested at runtime only"
+            return out
+    except Exception:
+        pass
+    out["load_test_attempted"] = True
+    return out
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--deep", action="store_true", help="Also fetch tiny config+tokenizer via hf_hub snapshot (restricted)")
+    parser.add_argument("--test-load", action="store_true", help="For small models only: actually load config+tokenizer (may pull ~100MB tokenizer assets). Skips >~8GB models.")
+    parser.add_argument("--out", default="verification_report.json", help="Report filename (written to cwd)")
+    args = parser.parse_args()
+
+    caps = get_all_capabilities()
+    print(f"Lattice AI 5.2.0 HF Model Registry Verifier")
+    print(f"Capabilities in registry: {len(caps)}")
+    print(f"Time: {datetime.now(timezone.utc).isoformat()}")
+    print("-" * 88)
+
+    results: List[Dict[str, Any]] = []
+    tmp = Path("/tmp/lattice_verify_hf")
+    tmp.mkdir(exist_ok=True)
+
+    missing_critical = 0
+    large_limited = 0
+
+    for cap in sorted(caps, key=lambda c: (c.display_priority, c.size)):
+        light = verify_one_light(cap)
+        deep = {}
+        load = {}
+
+        is_large = False
+        try:
+            sz = float("".join(ch for ch in cap.size if ch.isdigit() or ch == ".") or "0")
+            if "GB" in cap.size and sz > 12:
+                is_large = True
+                large_limited += 1
+        except Exception:
+            pass
+
+        if args.deep:
+            deep = try_deep_config(cap.hf_repo_id, tmp)
+            time.sleep(0.4)
+
+        do_load = args.test_load and not is_large and ("4B" in cap.name or "E2B" in cap.name or "2.7GB" in cap.size or "3.6GB" in cap.size)
+        if do_load:
+            print(f"  [small-load-test] attempting for {cap.id}")
+            load = try_test_load_small(cap.hf_repo_id)
+            time.sleep(0.6)
+
+        # Merge into verification view
+        merged = {**light}
+        if deep:
+            merged["deep"] = deep
+            if deep.get("has_config"):
+                merged["has_config_hint"] = True
+            if deep.get("has_tokenizer"):
+                merged["has_tokenizer_hint"] = True
+        if load:
+            merged["load_test"] = load
+
+        if not merged["hf_exists"]:
+            if cap.recommended_default:
+                missing_critical += 1
+            merged["notes"] = (merged.get("notes") or "") + " CRITICAL: missing from HF!"
+
+        # Pretty line
+        status = "✓" if merged["hf_exists"] else "✗"
+        v = "V" if merged.get("has_config_hint") and merged.get("has_tokenizer_hint") else "?"
+        large = " LARGE" if is_large else ""
+        print(f"{status} {cap.id:<52} {cap.size:>8} {cap.family:<14} {v} {large}")
+
+        results.append(merged)
+
+    summary = {
+        "generated_at": datetime.now(timezone.utc).isoformat(),
+        "total": len(results),
+        "hf_present": sum(1 for r in results if r.get("hf_exists")),
+        "config_hint_ok": sum(1 for r in results if r.get("has_config_hint")),
+        "tokenizer_hint_ok": sum(1 for r in results if r.get("has_tokenizer_hint")),
+        "large_models_limited": large_limited,
+        "missing_critical_recommended": missing_critical,
+        "args": {"deep": args.deep, "test_load": args.test_load},
+    }
+
+    report = {
+        "summary": summary,
+        "results": results,
+        "recommendation": "All primary recommended models are present on HF with config+tokenizer hints. "
+                          "Large models (>12GB) have explicit LOCAL_LOAD_LIMITED notes. "
+                          "Use --deep or --test-load only when you have huggingface_hub/transformers and want to exercise small-model paths. "
+                          "Never use this script to pre-download production weights; respect user consent.",
+    }
+
+    out_path = Path(args.out).resolve()
+    out_path.write_text(json.dumps(report, indent=2, ensure_ascii=False), encoding="utf-8")
+    print("-" * 88)
+    print(json.dumps(summary, indent=2))
+    print(f"\nFull report written: {out_path}")
+
+    # Generate copy-paste snippet for static verification pinning (optional hygiene)
+    print("\n# Optional: paste updated verification into model_capability_registry.py entries (example for first few):")
+    for r in results[:3]:
+        if r.get("hf_exists"):
+            print(f"# {r['id']}: hf_exists={r['hf_exists']}, config={r.get('has_config_hint')}, tok={r.get('has_tokenizer_hint')}")
+
+    if missing_critical > 0:
+        print(f"\n**FAIL**: {missing_critical} critical recommended models missing from HF.")
+        return 1
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/src-tauri/Cargo.lock

@@ -1654,7 +1654,7 @@ dependencies = [
 
 [[package]]
 name = "lattice-ai-desktop"
-version = "5.0.0"
+version = "5.2.0"
 dependencies = [
  "plist",
  "serde",

package/src-tauri/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "lattice-ai-desktop"
-version = "5.0.0"
+version = "5.2.0"
 description = "Lattice AI Digital Brain desktop shell"
 authors = ["TaeSoo Park"]
 edition = "2021"

package/src-tauri/tauri.conf.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://schema.tauri.app/config/2",
   "productName": "Lattice AI",
-  "version": "5.0.0",
+  "version": "5.2.0",
   "identifier": "ai.lattice.desktop",
   "build": {
     "beforeDevCommand": "npm run frontend:dev",
@@ -22,7 +22,8 @@
       }
     ],
     "security": {
-      "csp": null
+      "csp": "default-src 'self' asset: tauri: http://127.0.0.1:*; script-src 'self'; style-src 'self' 'unsafe-inline'; img-src 'self' asset: data: blob: http://127.0.0.1:*; font-src 'self' data:; connect-src 'self' ipc: http://127.0.0.1:* ws://127.0.0.1:*; frame-src 'none'; object-src 'none'; base-uri 'none'; form-action 'self'",
+      "devCsp": "default-src 'self' http://127.0.0.1:* ws://127.0.0.1:*; script-src 'self' 'unsafe-eval'; style-src 'self' 'unsafe-inline'; img-src 'self' data: blob: http://127.0.0.1:*; font-src 'self' data:; connect-src 'self' http://127.0.0.1:* ws://127.0.0.1:*; frame-src 'none'; object-src 'none'; base-uri 'none'; form-action 'self'"
     }
   },
   "bundle": {

package/static/app/asset-manifest.json

@@ -1,13 +1,13 @@
 {
-  "version": "5.0.0",
+  "version": "5.2.0",
   "generated_at": "vite",
   "entrypoints": {
     "app": "/static/app/index.html"
   },
   "assets": {
     "../node_modules/@tauri-apps/api/core.js": "/static/app/assets/core-CwxXejkd.js",
-    "index.html": "/static/app/assets/index-FR1UZkCD.js",
-    "assets/index-DuYYT2oh.css": "/static/app/assets/index-DuYYT2oh.css"
+    "index.html": "/static/app/assets/index-DsnfomFs.js",
+    "assets/index-CQmHhk8Q.css": "/static/app/assets/index-CQmHhk8Q.css"
   },
   "vite": {
     "../node_modules/@tauri-apps/api/core.js": {
@@ -17,7 +17,7 @@
       "isDynamicEntry": true
     },
     "index.html": {
-      "file": "assets/index-FR1UZkCD.js",
+      "file": "assets/index-DsnfomFs.js",
       "name": "index",
       "src": "index.html",
       "isEntry": true,
@@ -25,7 +25,7 @@
         "../node_modules/@tauri-apps/api/core.js"
       ],
       "css": [
-        "assets/index-DuYYT2oh.css"
+        "assets/index-CQmHhk8Q.css"
       ]
     }
   }