ltcai 3.0.1 → 3.1.0

package/scripts/build_v3_assets.mjs

@@ -0,0 +1,164 @@
+#!/usr/bin/env node
+/*
+ * Build the v3 browser asset manifest.
+ *
+ * The source files stay importable in development. This script writes hashed
+ * siblings next to each runtime asset, rewrites ES-module imports to those
+ * hashed siblings, and emits static/v3/asset-manifest.json for /app.
+ */
+import { createHash } from "node:crypto";
+import {
+  existsSync,
+  mkdirSync,
+  readdirSync,
+  readFileSync,
+  rmSync,
+  statSync,
+  writeFileSync,
+} from "node:fs";
+import { basename, dirname, extname, join, relative } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const repoRoot = join(dirname(fileURLToPath(import.meta.url)), "..");
+const staticRoot = join(repoRoot, "static");
+const manifestPath = join(staticRoot, "v3", "asset-manifest.json");
+
+const cssSources = [
+  "static/css/tokens.css",
+  "static/v3/css/lattice.tokens.css",
+  "static/v3/css/lattice.base.css",
+  "static/v3/css/lattice.components.css",
+  "static/v3/css/lattice.shell.css",
+  "static/v3/css/lattice.views.css",
+];
+
+const moduleRoot = join(staticRoot, "v3", "js");
+const entry = "static/v3/js/app.js";
+
+function posix(p) {
+  return p.replaceAll("\\", "/");
+}
+
+function sha(text) {
+  return createHash("sha256").update(text).digest("hex").slice(0, 8);
+}
+
+function repoPath(abs) {
+  return posix(relative(repoRoot, abs));
+}
+
+function publicUrl(repoRel) {
+  return "/" + posix(repoRel);
+}
+
+function walk(dir) {
+  const out = [];
+  for (const name of readdirSync(dir)) {
+    const p = join(dir, name);
+    const st = statSync(p);
+    if (st.isDirectory()) out.push(...walk(p));
+    else if (name.endsWith(".js")) out.push(p);
+  }
+  return out;
+}
+
+function removeGenerated(dir, ext) {
+  if (!existsSync(dir)) return;
+  for (const name of readdirSync(dir)) {
+    const p = join(dir, name);
+    const st = statSync(p);
+    if (st.isDirectory()) removeGenerated(p, ext);
+    else if (new RegExp(`\\.[0-9a-f]{8}\\${ext}$`).test(name)) rmSync(p);
+  }
+}
+
+removeGenerated(join(staticRoot, "css"), ".css");
+removeGenerated(join(staticRoot, "v3", "css"), ".css");
+removeGenerated(moduleRoot, ".js");
+
+const modules = new Map();
+for (const abs of walk(moduleRoot)) {
+  modules.set(repoPath(abs), {
+    abs,
+    rel: repoPath(abs),
+    source: readFileSync(abs, "utf8"),
+    deps: [],
+  });
+}
+
+const importFromRe = /\b(?:import|export)\s+(?:[^"'()]*?\s+from\s*)?["']([^"']+\.js)["']/g;
+for (const mod of modules.values()) {
+  const deps = [];
+  let match;
+  while ((match = importFromRe.exec(mod.source))) {
+    const spec = match[1];
+    if (!spec.startsWith(".")) continue;
+    const depRel = repoPath(join(dirname(mod.abs), spec));
+    if (modules.has(depRel)) deps.push(depRel);
+  }
+  mod.deps = deps;
+}
+
+const hashMemo = new Map();
+function moduleHash(rel, stack = []) {
+  if (hashMemo.has(rel)) return hashMemo.get(rel);
+  if (stack.includes(rel)) return sha(modules.get(rel).source);
+  const mod = modules.get(rel);
+  const depHashes = mod.deps
+    .sort()
+    .map((dep) => `${dep}:${moduleHash(dep, [...stack, rel])}`)
+    .join("\n");
+  const h = sha(`${mod.source}\n/* dependency-hashes */\n${depHashes}`);
+  hashMemo.set(rel, h);
+  return h;
+}
+
+for (const rel of modules.keys()) moduleHash(rel);
+
+function hashedRel(rel, hash) {
+  const ext = extname(rel);
+  return posix(join(dirname(rel), `${basename(rel, ext)}.${hash}${ext}`));
+}
+
+const assets = {};
+
+for (const sourceRel of cssSources) {
+  const abs = join(repoRoot, sourceRel);
+  const source = readFileSync(abs, "utf8");
+  const outRel = hashedRel(sourceRel, sha(source));
+  writeFileSync(join(repoRoot, outRel), source, "utf8");
+  assets[sourceRel] = publicUrl(outRel);
+}
+
+function rewriteModule(mod) {
+  return mod.source.replace(importFromRe, (full, spec) => {
+    if (!spec.startsWith(".")) return full;
+    const depRel = repoPath(join(dirname(mod.abs), spec));
+    const depHash = hashMemo.get(depRel);
+    if (!depHash) return full;
+    const depOutAbs = join(repoRoot, hashedRel(depRel, depHash));
+    const nextSpec = posix(relative(dirname(join(repoRoot, hashedRel(mod.rel, hashMemo.get(mod.rel)))), depOutAbs));
+    const normalized = nextSpec.startsWith(".") ? nextSpec : `./${nextSpec}`;
+    return full.replace(spec, normalized);
+  });
+}
+
+for (const mod of modules.values()) {
+  const outRel = hashedRel(mod.rel, hashMemo.get(mod.rel));
+  mkdirSync(dirname(join(repoRoot, outRel)), { recursive: true });
+  writeFileSync(join(repoRoot, outRel), rewriteModule(mod), "utf8");
+  assets[mod.rel] = publicUrl(outRel);
+}
+
+const manifest = {
+  version: "3.1.0",
+  generated_at: "deterministic",
+  entrypoints: {
+    app: assets[entry],
+    styles: cssSources.map((rel) => assets[rel]),
+  },
+  assets,
+};
+
+writeFileSync(manifestPath, JSON.stringify(manifest, null, 2) + "\n", "utf8");
+console.log(`wrote ${repoPath(manifestPath)} with ${Object.keys(assets).length} assets`);

package/scripts/capture/README.md

@@ -0,0 +1,28 @@
+# Screenshot Capture
+
+Reproducible Playwright capture scripts for release screenshots.
+
+Prerequisites:
+
+```bash
+npm ci
+npx playwright install chromium
+LTCAI
+```
+
+Optional environment:
+
+- `LTCAI_CAPTURE_BASE_URL` defaults to `http://localhost:4825`
+- `SESSION_TOKEN` or `LTCAI_SESSION_TOKEN` injects an authenticated session cookie
+- `LTCAI_CAPTURE_OUT` defaults to `docs/images`
+- `LTCAI_CAPTURE_HEADED=1` runs with a visible browser
+
+Commands:
+
+```bash
+npm run capture:workspace
+npm run capture:graph
+npm run capture:skills
+npm run capture:enterprise
+npm run capture:onboarding
+```

package/scripts/capture/capture_enterprise.js

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+const { capturePage } = require("./capture_page");
+
+capturePage({ path: "/admin#enterprise", waitFor: "#enterprise-capability-status", filename: "enterprise.png" })
+  .catch((error) => {
+    console.error(error);
+    process.exit(1);
+  });

package/scripts/capture/capture_graph.js

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+const { capturePage } = require("./capture_page");
+
+capturePage({ path: "/graph", waitFor: "#graph", filename: "graph.png", settleMs: 1400 })
+  .catch((error) => {
+    console.error(error);
+    process.exit(1);
+  });

package/scripts/capture/capture_onboarding.js

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+const { capturePage } = require("./capture_page");
+
+capturePage({ path: "/onboarding", waitFor: "#onboarding-steps", filename: "onboarding.png" })
+  .catch((error) => {
+    console.error(error);
+    process.exit(1);
+  });

package/scripts/capture/capture_page.js

@@ -0,0 +1,43 @@
+const fs = require("fs");
+const path = require("path");
+
+async function loadPlaywright() {
+  try {
+    return require("@playwright/test");
+  } catch (_) {
+    return require("playwright");
+  }
+}
+
+async function capturePage(options) {
+  const { chromium } = await loadPlaywright();
+  const baseURL = process.env.LTCAI_CAPTURE_BASE_URL || "http://localhost:4825";
+  const outDir = path.resolve(process.env.LTCAI_CAPTURE_OUT || path.join(__dirname, "..", "..", "docs", "images"));
+  const sessionToken = process.env.SESSION_TOKEN || process.env.LTCAI_SESSION_TOKEN || "";
+  fs.mkdirSync(outDir, { recursive: true });
+
+  const browser = await chromium.launch({ headless: process.env.LTCAI_CAPTURE_HEADED !== "1" });
+  const context = await browser.newContext({
+    viewport: { width: Number(process.env.LTCAI_CAPTURE_WIDTH || 1440), height: Number(process.env.LTCAI_CAPTURE_HEIGHT || 920) },
+    deviceScaleFactor: Number(process.env.LTCAI_CAPTURE_SCALE || 2),
+  });
+  if (sessionToken) {
+    const host = new URL(baseURL).hostname;
+    await context.addCookies([{ name: "session_token", value: sessionToken, domain: host, path: "/", httpOnly: true, secure: false }]);
+  }
+
+  const page = await context.newPage();
+  const target = new URL(options.path, baseURL).toString();
+  await page.goto(target, { waitUntil: "networkidle", timeout: Number(process.env.LTCAI_CAPTURE_TIMEOUT || 30_000) });
+  if (options.hash) await page.evaluate((hash) => { location.hash = hash; }, options.hash);
+  if (options.waitFor) await page.waitForSelector(options.waitFor, { timeout: 15_000 });
+  await page.waitForTimeout(Number(process.env.LTCAI_CAPTURE_SETTLE_MS || options.settleMs || 900));
+
+  const outPath = path.join(outDir, options.filename);
+  await page.screenshot({ path: outPath, fullPage: Boolean(options.fullPage) });
+  await browser.close();
+  console.log(outPath);
+  return outPath;
+}
+
+module.exports = { capturePage };

package/scripts/capture/capture_release_media.js

@@ -0,0 +1,125 @@
+#!/usr/bin/env node
+const fs = require("fs");
+const path = require("path");
+const { spawnSync } = require("child_process");
+
+async function loadPlaywright() {
+  try {
+    return require("@playwright/test");
+  } catch (_) {
+    return require("playwright");
+  }
+}
+
+const ROOT = path.resolve(__dirname, "..", "..");
+const OUT = path.join(ROOT, "docs", "images");
+const FRAMES = path.join(OUT, "tmp_frames", "release_221");
+const BASE = process.env.LTCAI_CAPTURE_BASE_URL || "http://127.0.0.1:4825";
+
+function ensureDirs() {
+  fs.mkdirSync(OUT, { recursive: true });
+  fs.rmSync(FRAMES, { recursive: true, force: true });
+  fs.mkdirSync(FRAMES, { recursive: true });
+}
+
+async function preparePage(page, theme = "light") {
+  await page.addInitScript((mode) => {
+    localStorage.setItem("lt-theme", mode);
+    localStorage.setItem("ltcai_workspace_type", "personal");
+    localStorage.setItem("ltcai_mode", "advanced");
+    localStorage.setItem("ltcai_user_email", "demo@lattice.local");
+    localStorage.setItem("ltcai_is_admin", "true");
+    sessionStorage.setItem("ltcai_force_setup_after_login", "false");
+  }, theme);
+}
+
+async function gotoReady(page, pathname, selector, theme = "light") {
+  await preparePage(page, theme);
+  await page.goto(new URL(pathname, BASE).toString(), { waitUntil: "domcontentloaded", timeout: 30000 });
+  if (selector) await page.waitForSelector(selector, { timeout: 20000 });
+  await page.evaluate((mode) => {
+    document.documentElement.setAttribute("data-lt-theme", mode);
+    document.body.dataset.capture = "release-221";
+  }, theme);
+  await page.waitForTimeout(1800);
+}
+
+async function screenshot(page, filename, options = {}) {
+  const out = path.join(OUT, filename);
+  await page.screenshot({ path: out, fullPage: Boolean(options.fullPage) });
+  console.log(out);
+}
+
+async function captureAll() {
+  ensureDirs();
+  const { chromium } = await loadPlaywright();
+  const browser = await chromium.launch({ headless: true });
+
+  const desktop = await browser.newContext({
+    viewport: { width: 1440, height: 920 },
+    deviceScaleFactor: 1,
+  });
+  const mobile = await browser.newContext({
+    viewport: { width: 390, height: 844 },
+    deviceScaleFactor: 2,
+    isMobile: true,
+  });
+
+  let page = await desktop.newPage();
+  await gotoReady(page, "/workspace", "#workspace-health-grid", "light");
+  await screenshot(page, "workspace-light.png");
+  await screenshot(page, "lattice-ai-hero.png");
+
+  await page.evaluate(() => document.documentElement.setAttribute("data-lt-theme", "dark"));
+  await page.waitForTimeout(800);
+  await screenshot(page, "workspace-dark.png");
+
+  await gotoReady(page, "/graph", "#graph", "dark");
+  await screenshot(page, "knowledge-graph.png");
+
+  await gotoReady(page, "/workflows", "#wfNodes", "light");
+  await screenshot(page, "pipeline.png");
+
+  await gotoReady(page, "/admin", "#admin-root, .admin-shell, body", "light");
+  await page.waitForTimeout(2200);
+  await screenshot(page, "admin-dashboard.png");
+
+  const mobilePage = await mobile.newPage();
+  await gotoReady(mobilePage, "/chat", ".reference-shell, body", "light");
+  await screenshot(mobilePage, "mobile-responsive.png", { fullPage: false });
+
+  const framePlan = [
+    ["/workspace", "#workspace-health-grid", "light"],
+    ["/workspace", "#workspace-health-grid", "dark"],
+    ["/graph", "#graph", "dark"],
+    ["/workflows", "#wfNodes", "light"],
+    ["/chat", ".reference-shell, body", "light"],
+  ];
+  let frame = 0;
+  for (const [pathname, selector, theme] of framePlan) {
+    await gotoReady(page, pathname, selector, theme);
+    for (let repeat = 0; repeat < 3; repeat += 1) {
+      await page.screenshot({ path: path.join(FRAMES, `frame_${String(frame).padStart(3, "0")}.png`) });
+      frame += 1;
+    }
+  }
+
+  await browser.close();
+
+  const gifPath = path.join(OUT, "lattice-ai-demo.gif");
+  const ffmpeg = spawnSync("ffmpeg", [
+    "-y",
+    "-framerate", "1.5",
+    "-i", path.join(FRAMES, "frame_%03d.png"),
+    "-vf", "scale=1280:-1:flags=lanczos,fps=6",
+    "-loop", "0",
+    gifPath,
+  ], { stdio: "inherit" });
+  if (ffmpeg.status !== 0) process.exit(ffmpeg.status || 1);
+  console.log(gifPath);
+}
+
+captureAll().catch((error) => {
+  console.error(error);
+  process.exit(1);
+});

package/scripts/capture/capture_skills.js

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+const { capturePage } = require("./capture_page");
+
+capturePage({ path: "/workspace#skills", waitFor: "#skill-list", filename: "skills.png" })
+  .catch((error) => {
+    console.error(error);
+    process.exit(1);
+  });

package/scripts/capture/capture_workspace.js

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+const { capturePage } = require("./capture_page");
+
+capturePage({ path: "/workspace", waitFor: "#workspace-health-grid", filename: "workspace.png" })
+  .catch((error) => {
+    console.error(error);
+    process.exit(1);
+  });