ltcai 4.0.1 → 4.1.0

package/frontend/src/store/appStore.ts

@@ -0,0 +1,54 @@
+import { create } from "zustand";
+
+export type Theme = "dark" | "light";
+export type WorkspaceMode = "basic" | "advanced" | "admin";
+
+type AppState = {
+  theme: Theme;
+  mode: WorkspaceMode;
+  workspaceId: string | null;
+  apiBase: string | null;
+  setTheme: (theme: Theme) => void;
+  setMode: (mode: WorkspaceMode) => void;
+  setWorkspaceId: (workspaceId: string | null) => void;
+  setApiBase: (apiBase: string | null) => void;
+};
+
+function readTheme(): Theme {
+  try {
+    const saved = localStorage.getItem("lattice.theme");
+    if (saved === "light" || saved === "dark") return saved;
+  } catch {}
+  return "dark";
+}
+
+function readMode(): WorkspaceMode {
+  try {
+    const saved = localStorage.getItem("lattice.mode");
+    if (saved === "basic" || saved === "advanced" || saved === "admin") return saved;
+  } catch {}
+  return "basic";
+}
+
+export const useAppStore = create<AppState>((set) => ({
+  theme: readTheme(),
+  mode: readMode(),
+  workspaceId: null,
+  apiBase: null,
+  setTheme: (theme) => {
+    document.documentElement.dataset.theme = theme;
+    try { localStorage.setItem("lattice.theme", theme); } catch {}
+    set({ theme });
+  },
+  setMode: (mode) => {
+    try { localStorage.setItem("lattice.mode", mode); } catch {}
+    set({ mode });
+  },
+  setWorkspaceId: (workspaceId) => {
+    if (workspaceId) {
+      try { localStorage.setItem("lattice.workspace", workspaceId); } catch {}
+    }
+    set({ workspaceId });
+  },
+  setApiBase: (apiBase) => set({ apiBase }),
+}));

package/frontend/src/styles.css

@@ -0,0 +1,107 @@
+@import "tailwindcss";
+@import "reactflow/dist/style.css";
+
+:root {
+  color-scheme: dark;
+  --background: 220 18% 8%;
+  --foreground: 210 30% 96%;
+  --card: 220 16% 11%;
+  --card-foreground: 210 30% 96%;
+  --muted: 218 13% 18%;
+  --muted-foreground: 215 14% 66%;
+  --primary: 176 68% 48%;
+  --primary-foreground: 212 26% 8%;
+  --secondary: 221 14% 20%;
+  --secondary-foreground: 210 30% 96%;
+  --destructive: 355 78% 58%;
+  --destructive-foreground: 0 0% 100%;
+  --border: 218 13% 23%;
+  --input: 218 13% 24%;
+  --ring: 176 68% 48%;
+  --brain: 176 68% 48%;
+  --ask: 216 78% 66%;
+  --capture: 142 58% 56%;
+  --act: 33 92% 58%;
+  --library: 262 68% 70%;
+  --system: 350 72% 68%;
+}
+
+:root[data-theme="light"] {
+  color-scheme: light;
+  --background: 210 30% 98%;
+  --foreground: 222 38% 9%;
+  --card: 0 0% 100%;
+  --card-foreground: 222 38% 9%;
+  --muted: 213 24% 92%;
+  --muted-foreground: 219 11% 38%;
+  --primary: 178 72% 32%;
+  --primary-foreground: 0 0% 100%;
+  --secondary: 211 24% 90%;
+  --secondary-foreground: 222 38% 9%;
+  --destructive: 355 72% 48%;
+  --destructive-foreground: 0 0% 100%;
+  --border: 214 20% 83%;
+  --input: 214 20% 78%;
+  --ring: 178 72% 32%;
+}
+
+@theme inline {
+  --color-background: hsl(var(--background));
+  --color-foreground: hsl(var(--foreground));
+  --color-card: hsl(var(--card));
+  --color-card-foreground: hsl(var(--card-foreground));
+  --color-muted: hsl(var(--muted));
+  --color-muted-foreground: hsl(var(--muted-foreground));
+  --color-primary: hsl(var(--primary));
+  --color-primary-foreground: hsl(var(--primary-foreground));
+  --color-secondary: hsl(var(--secondary));
+  --color-secondary-foreground: hsl(var(--secondary-foreground));
+  --color-destructive: hsl(var(--destructive));
+  --color-destructive-foreground: hsl(var(--destructive-foreground));
+  --color-border: hsl(var(--border));
+  --color-input: hsl(var(--input));
+  --color-ring: hsl(var(--ring));
+}
+
+* {
+  box-sizing: border-box;
+}
+
+body {
+  min-width: 320px;
+  margin: 0;
+  background: hsl(var(--background));
+  color: hsl(var(--foreground));
+  font-family: Inter, ui-sans-serif, system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif;
+}
+
+button,
+input,
+textarea,
+select {
+  font: inherit;
+}
+
+.brain-grid {
+  background-image:
+    linear-gradient(hsl(var(--border) / 0.34) 1px, transparent 1px),
+    linear-gradient(90deg, hsl(var(--border) / 0.34) 1px, transparent 1px);
+  background-size: 32px 32px;
+}
+
+.scrollbar-thin {
+  scrollbar-width: thin;
+}
+
+.react-flow__node {
+  border: 1px solid hsl(var(--border));
+  border-radius: 8px;
+  background: hsl(var(--card));
+  color: hsl(var(--foreground));
+  padding: 8px 10px;
+  font-size: 12px;
+}
+
+.react-flow__edge-path {
+  stroke: hsl(var(--primary));
+}

package/latticeai/__init__.py

@@ -1,3 +1,3 @@
 """Lattice AI - modular server package."""
 
-__version__ = "4.0.1"
+__version__ = "4.1.0"

package/latticeai/api/setup.py

@@ -19,15 +19,16 @@ from latticeai.models.router import parse_model_ref
 from setup_wizard import get_recommendations, install_stream, open_url, scan_environment
 
 
+class SetupInstallRequest(BaseModel):
+    items: List[Dict]
+
+
 def create_setup_router(*, model_router, require_user) -> APIRouter:
     api_router = APIRouter()
     router = model_router
 
     # ── Setup Wizard ─────────────────────────────────────────────────────────────
-    
-    class SetupInstallRequest(BaseModel):
-        items: List[Dict]
-    
+
     def setup_auto_state() -> Dict[str, object]:
         """Return the PPT-aligned zero-config setup state used by setup UI/API."""
         profile = auto_setup_probe()

package/latticeai/api/static_routes.py

@@ -84,7 +84,7 @@ def create_static_routes_router(
             raise HTTPException(status_code=404)
         return FileResponse(str(p), media_type="application/manifest+json")
 
-    @api_router.api_route("/favicon.ico", methods=["GET", "HEAD"])
+    @api_router.api_route("/favicon.ico", methods=["GET", "HEAD"], include_in_schema=False)
     async def favicon():
         ico = STATIC_DIR / "favicon.ico"
         png = STATIC_DIR / "icons" / "favicon-32.png"
@@ -112,10 +112,10 @@ def create_static_routes_router(
 
     @api_router.get("/app")
     async def app_shell(request: Request):
-        """v3 single-page workspace shell (token-native design system)."""
-        page = STATIC_DIR / "v3" / "index.html"
+        """React desktop single-page workspace shell."""
+        page = STATIC_DIR / "app" / "index.html"
         if not page.exists():
-            raise HTTPException(status_code=404, detail="v3 shell not found.")
+            raise HTTPException(status_code=404, detail="React shell not found.")
         return ui_file_response(page)
 
 

package/latticeai/core/marketplace.py

@@ -11,7 +11,7 @@ from copy import deepcopy
 from typing import Any, Dict, List, Optional
 
 
-MARKETPLACE_VERSION = "4.0.1"
+MARKETPLACE_VERSION = "4.1.0"
 TEMPLATE_KINDS = ("plugin", "workflow", "agent")
 
 

package/latticeai/core/multi_agent.py

@@ -14,7 +14,7 @@ from datetime import datetime
 from typing import Any, Callable, Dict, List, Optional
 
 
-MULTI_AGENT_VERSION = "4.0.1"
+MULTI_AGENT_VERSION = "4.1.0"
 
 AGENT_ROLES = ("researcher", "planner", "executor", "reviewer", "release")
 CORE_PIPELINE = ("planner", "executor", "reviewer")

package/latticeai/core/workspace_os.py

@@ -19,7 +19,7 @@ from pathlib import Path
 from typing import Any, Callable, Dict, Iterable, List, Optional
 
 
-WORKSPACE_OS_VERSION = "4.0.1"
+WORKSPACE_OS_VERSION = "4.1.0"
 
 # Workspace types separate single-user Personal workspaces from shared
 # Organization workspaces. Both keep the same local-first JSON store; the type

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ltcai",
-  "version": "4.0.1",
+  "version": "4.1.0",
   "description": "Lattice AI — local-first Digital Brain Platform (knowledge graph, durable memory, hybrid search, agents, signed brain exchange)",
   "homepage": "https://github.com/TaeSooPark-PTS/LatticeAI#readme",
   "repository": {
@@ -18,29 +18,36 @@
     "start": "LTCAI",
     "dev": "python3 ltcai_cli.py --reload",
     "build": "npm run build:assets && npm run build:python",
-    "build:assets": "node scripts/build_v3_assets.mjs",
-    "build:python": "python3 -m build",
-    "check:python": "python3 scripts/check_python.py",
-    "lint": "node --check tests/visual/mock_server.cjs && node --check tests/visual/v3.spec.js && npm run lint:v3",
-    "lint:v3": "node scripts/lint_v3.mjs",
-    "typecheck": "cd vscode-extension && npm run build",
-    "test": "python3 -m pytest tests/ -v",
-    "test:unit": "python3 -m pytest tests/unit/ -v",
-    "test:integration": "python3 -m pytest tests/integration/ -v",
+    "frontend:dev": "vite --host 127.0.0.1",
+    "frontend:openapi": "node scripts/run_python.mjs scripts/export_openapi.py frontend/openapi.json && npx openapi-typescript frontend/openapi.json -o frontend/src/api/openapi.ts",
+    "build:assets": "vite build && node scripts/build_frontend_assets.mjs",
+    "build:python": "node scripts/run_python.mjs -m build",
+    "check:python": "node scripts/run_python.mjs scripts/check_python.py",
+    "lint": "node --check tests/visual/mock_server.cjs && node --check tests/visual/v3.spec.js && npm run lint:frontend",
+    "lint:frontend": "node scripts/lint_frontend.mjs",
+    "typecheck": "npm run typecheck:frontend && cd vscode-extension && npm run build",
+    "typecheck:frontend": "npx tsc -p tsconfig.json --noEmit",
+    "test": "node scripts/run_python.mjs -m pytest tests/ -v",
+    "test:unit": "node scripts/run_python.mjs -m pytest tests/unit/ -v",
+    "test:integration": "node scripts/run_python.mjs -m pytest tests/integration/ -v",
     "test:visual": "playwright test",
     "capture:workspace": "node scripts/capture/capture_workspace.js",
     "capture:graph": "node scripts/capture/capture_graph.js",
     "capture:skills": "node scripts/capture/capture_skills.js",
     "capture:enterprise": "node scripts/capture/capture_enterprise.js",
     "capture:onboarding": "node scripts/capture/capture_onboarding.js",
+    "desktop:tauri": "tauri dev",
+    "desktop:tauri:build": "tauri build",
+    "desktop:tauri:check": "cd src-tauri && cargo check",
+    "desktop:electron": "electron desktop/electron/main.cjs",
     "package:vsix": "node scripts/build_vsix.mjs",
     "release:artifacts": "npm run build:assets && npm run build:python && npm pack && npm run package:vsix",
-    "release:validate": "python3 scripts/validate_release_artifacts.py $npm_package_version --require-vsix --require-tgz",
+    "release:validate": "node scripts/run_python.mjs scripts/validate_release_artifacts.py $npm_package_version --require-vsix --require-tgz",
     "publish:npm": "npm pack && npm publish ltcai-$npm_package_version.tgz --access public",
-    "publish:pypi": "npm run build:python && python3 -m twine upload --skip-existing dist/ltcai-$npm_package_version.tar.gz dist/ltcai-$npm_package_version-py3-none-any.whl",
+    "publish:pypi": "npm run build:python && node scripts/run_python.mjs -m twine upload --skip-existing dist/ltcai-$npm_package_version.tar.gz dist/ltcai-$npm_package_version-py3-none-any.whl",
     "publish:vscode": "cd vscode-extension && npm run package:vsix && npm run publish:vscode",
     "publish:openvsx": "cd vscode-extension && npm run package:vsix && npm run publish:openvsx",
-    "publish:all": "npm run release:artifacts && npm run release:validate && npm publish ltcai-$npm_package_version.tgz --access public && python3 -m twine upload --skip-existing dist/ltcai-$npm_package_version.tar.gz dist/ltcai-$npm_package_version-py3-none-any.whl && cd vscode-extension && npm run publish:vscode && npm run publish:openvsx"
+    "publish:all": "npm run release:artifacts && npm run release:validate && npm publish ltcai-$npm_package_version.tgz --access public && node scripts/run_python.mjs -m twine upload --skip-existing dist/ltcai-$npm_package_version.tar.gz dist/ltcai-$npm_package_version-py3-none-any.whl && cd vscode-extension && npm run publish:vscode && npm run publish:openvsx"
   },
   "keywords": [
     "ltcai",
@@ -78,7 +85,8 @@
     "static/manifest.json",
     "static/sw.js",
     "static/css/",
-    "static/v3/",
+    "frontend/",
+    "static/app/",
     "static/icons/",
     "plugins/",
     "scripts/",
@@ -89,6 +97,12 @@
     "setup_wizard.py",
     "knowledge_graph_api.py",
     "static/vendor/",
+    "src-tauri/",
+    "!src-tauri/gen/",
+    "!src-tauri/gen/**",
+    "!src-tauri/target/",
+    "!src-tauri/target/**",
+    "desktop/electron/",
     "docs/*.md",
     "!docs/assets/",
     "!docs/images/"
@@ -97,6 +111,31 @@
     "access": "public"
   },
   "devDependencies": {
-    "@playwright/test": "^1.60.0"
+    "@playwright/test": "^1.60.0",
+    "@tailwindcss/postcss": "^4.3.0",
+    "@tanstack/react-query": "^5.101.0",
+    "@tauri-apps/api": "^2.0.0",
+    "@tauri-apps/cli": "^2.0.0",
+    "@types/cytoscape": "^3.21.9",
+    "@types/react": "^19.2.17",
+    "@types/react-dom": "^19.2.3",
+    "@vitejs/plugin-react": "^6.0.2",
+    "autoprefixer": "^10.5.0",
+    "class-variance-authority": "^0.7.1",
+    "clsx": "^2.1.1",
+    "cytoscape": "^3.34.0",
+    "electron": "^42.4.0",
+    "lucide-react": "^1.17.0",
+    "openapi-fetch": "^0.17.0",
+    "openapi-typescript": "^7.13.0",
+    "postcss": "^8.5.15",
+    "react": "^19.2.7",
+    "react-dom": "^19.2.7",
+    "reactflow": "^11.11.4",
+    "tailwind-merge": "^3.6.0",
+    "tailwindcss": "^4.3.0",
+    "typescript": "^5.9.3",
+    "vite": "^8.0.16",
+    "zustand": "^5.0.14"
   }
 }

package/scripts/build_frontend_assets.mjs

@@ -0,0 +1,38 @@
+#!/usr/bin/env node
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+
+const repo = join(import.meta.dirname, "..");
+const appDir = join(repo, "static", "app");
+const nestedViteManifest = join(appDir, ".vite", "asset-manifest.json");
+const publicManifest = join(appDir, "asset-manifest.json");
+const pkg = JSON.parse(readFileSync(join(repo, "package.json"), "utf8"));
+
+const viteManifest = existsSync(nestedViteManifest) ? nestedViteManifest : publicManifest;
+if (!existsSync(viteManifest)) {
+  console.error("Vite manifest missing. Run `vite build` before build_frontend_assets.mjs.");
+  process.exit(1);
+}
+
+const raw = JSON.parse(readFileSync(viteManifest, "utf8"));
+const assets = {};
+for (const [key, value] of Object.entries(raw)) {
+  if (value && typeof value === "object") {
+    if (value.file) assets[key] = `/static/app/${value.file}`;
+    for (const css of value.css || []) assets[css] = `/static/app/${css}`;
+    for (const asset of value.assets || []) assets[asset] = `/static/app/${asset}`;
+  }
+}
+
+const manifest = {
+  version: pkg.version,
+  generated_at: "vite",
+  entrypoints: {
+    app: assets["frontend/index.html"] || "/static/app/index.html",
+  },
+  assets,
+  vite: raw,
+};
+
+writeFileSync(publicManifest, JSON.stringify(manifest, null, 2) + "\n", "utf8");
+console.log(`wrote static/app/asset-manifest.json with ${Object.keys(assets).length} assets`);

package/scripts/bump_version.py

@@ -31,7 +31,7 @@ TARGETS = [
     ("package-lock.json", "package-lock", None),
     ("vscode-extension/package.json", "json", "version"),
     ("vscode-extension/package-lock.json", "package-lock", None),
-    ("static/v3/asset-manifest.json", "json", "version"),
+    ("static/app/asset-manifest.json", "json", "version"),
 ]
 
 

package/scripts/export_openapi.py

@@ -0,0 +1,31 @@
+#!/usr/bin/env python3
+"""Export the FastAPI OpenAPI schema used by the desktop frontend client."""
+
+from __future__ import annotations
+
+import json
+import os
+import sys
+from pathlib import Path
+
+REPO = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(REPO))
+
+
+def main() -> int:
+    from latticeai.app_factory import create_app
+
+    target = Path(sys.argv[1] if len(sys.argv) > 1 else "frontend/openapi.json")
+    target.parent.mkdir(parents=True, exist_ok=True)
+    os.environ.setdefault("LATTICEAI_REQUIRE_AUTH", "false")
+    os.environ.setdefault("LATTICEAI_TUNNEL", "false")
+    os.environ.setdefault("LATTICEAI_AUTOLOAD_MODELS", "false")
+    app = create_app()
+    schema = app.openapi()
+    target.write_text(json.dumps(schema, sort_keys=True, indent=2) + "\n", encoding="utf-8")
+    print(f"wrote {target} with {len(schema.get('paths', {}))} paths")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/scripts/lint_frontend.mjs

@@ -0,0 +1,86 @@
+#!/usr/bin/env node
+import { readdirSync, readFileSync, statSync, existsSync } from "node:fs";
+import { join, relative } from "node:path";
+import { spawnSync } from "node:child_process";
+
+const repo = join(import.meta.dirname, "..");
+const frontend = join(repo, "frontend");
+const staticRoot = join(repo, "static");
+let failures = 0;
+
+function fail(message) {
+  failures += 1;
+  console.error(`FAIL ${message}`);
+}
+
+function walk(dir, exts) {
+  if (!existsSync(dir)) return [];
+  const out = [];
+  for (const name of readdirSync(dir)) {
+    const path = join(dir, name);
+    const stat = statSync(path);
+    if (stat.isDirectory()) {
+      if (name === "node_modules") continue;
+      out.push(...walk(path, exts));
+    } else if (exts.some((ext) => name.endsWith(ext))) {
+      out.push(path);
+    }
+  }
+  return out;
+}
+
+const tsc = spawnSync("npx", ["tsc", "-p", "tsconfig.json", "--noEmit"], { cwd: repo, encoding: "utf8" });
+if (tsc.status !== 0) fail(`frontend typecheck\n${tsc.stdout}${tsc.stderr}`);
+else console.log("typecheck: frontend TS passes");
+
+const files = [
+  ...walk(frontend, [".ts", ".tsx", ".css", ".html"]),
+  ...walk(join(staticRoot, "app"), [".js", ".css", ".html", ".json"]),
+  join(staticRoot, "sw.js"),
+  join(staticRoot, "manifest.json"),
+].filter(existsSync);
+
+const external = /https?:\/\/(fonts\.googleapis\.com|fonts\.gstatic\.com|cdn\.jsdelivr\.net|unpkg\.com|cdnjs\.cloudflare\.com)/;
+const stale = /static\/v3|lint_v3|build_v3_assets/;
+let scanned = 0;
+for (const file of files) {
+  scanned += 1;
+  const text = readFileSync(file, "utf8");
+  if (external.test(text)) fail(`${relative(repo, file)}: CDN reference`);
+  if (stale.test(text)) fail(`${relative(repo, file)}: stale v3 frontend reference`);
+}
+console.log(`privacy: ${scanned} frontend/static files scanned`);
+
+const client = readFileSync(join(frontend, "src", "api", "client.ts"), "utf8");
+if (!client.includes("openapi-fetch") || !client.includes("./openapi")) {
+  fail("frontend/src/api/client.ts must use the generated OpenAPI client");
+}
+if (!existsSync(join(frontend, "src", "api", "openapi.ts"))) {
+  fail("generated OpenAPI types missing");
+}
+
+const openapi = JSON.parse(readFileSync(join(frontend, "openapi.json"), "utf8"));
+const openapiPaths = Object.keys(openapi.paths || {});
+const requiredPaths = [
+  "/health",
+  "/chat",
+  "/api/graph",
+  "/api/search/hybrid",
+  "/api/knowledge-graph/export",
+  "/api/memory/recall",
+  "/agents/api/run",
+  "/workflows/api/definitions",
+  "/workspace/os",
+  "/models",
+];
+if (openapiPaths.length < 300) fail(`OpenAPI path count too low: ${openapiPaths.length}`);
+for (const path of requiredPaths) {
+  if (!openapiPaths.includes(path)) fail(`OpenAPI path missing: ${path}`);
+}
+console.log(`api: generated OpenAPI schema exposes ${openapiPaths.length} paths`);
+
+if (failures) {
+  console.error(`\nfrontend lint: ${failures} failure(s)`);
+  process.exit(1);
+}
+console.log("\nfrontend lint: all checks pass");

package/scripts/run_python.mjs

@@ -0,0 +1,47 @@
+#!/usr/bin/env node
+import { existsSync } from "node:fs";
+import path from "node:path";
+import { spawnSync } from "node:child_process";
+
+const args = process.argv.slice(2);
+
+if (args.length === 0) {
+  console.error("usage: node scripts/run_python.mjs <python-args...>");
+  process.exit(2);
+}
+
+const candidates = [
+  process.env.LTCAI_PYTHON,
+  path.join(process.cwd(), ".venv", "bin", "python"),
+  path.join(process.cwd(), ".venv", "Scripts", "python.exe"),
+  "python3",
+  "python",
+].filter(Boolean);
+
+let lastError = null;
+
+for (const candidate of candidates) {
+  const isPath = candidate.includes(path.sep);
+  if (isPath && !existsSync(candidate)) {
+    continue;
+  }
+
+  const result = spawnSync(candidate, args, {
+    cwd: process.cwd(),
+    env: process.env,
+    stdio: "inherit",
+  });
+
+  if (result.error) {
+    if (result.error.code === "ENOENT") {
+      lastError = result.error;
+      continue;
+    }
+    throw result.error;
+  }
+
+  process.exit(result.status ?? 1);
+}
+
+console.error(`No usable Python executable found. Last error: ${lastError?.message ?? "none"}`);
+process.exit(127);