ltcai 4.0.1 → 4.2.0

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,91 @@
+#!/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",
+  "/api/brain/storage",
+  "/api/brain/storage/postgres/docker",
+  "/api/brain/storage/migrate-postgres",
+  "/api/knowledge-graph/archive",
+  "/api/knowledge-graph/archive/restore",
+];
+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/migrate_brain_storage.py

@@ -0,0 +1,53 @@
+#!/usr/bin/env python3
+"""Brain storage migration utility.
+
+Examples:
+    python scripts/migrate_brain_storage.py plan --sqlite ~/.ltcai/knowledge_graph.sqlite --dsn postgresql://...
+    python scripts/migrate_brain_storage.py migrate --sqlite ~/.ltcai/knowledge_graph.sqlite --dsn postgresql://...
+    python scripts/migrate_brain_storage.py docker-plan --data-dir ~/.ltcai/postgres
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+from pathlib import Path
+
+from lattice_brain.storage import DockerPostgresWizard, PostgresEngine, SQLiteToPostgresMigrator
+
+
+def _print_json(value: object) -> None:
+    print(json.dumps(value, ensure_ascii=False, indent=2))
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description=__doc__)
+    sub = parser.add_subparsers(dest="command", required=True)
+
+    for name in ("plan", "migrate"):
+        p = sub.add_parser(name)
+        p.add_argument("--sqlite", type=Path, required=True)
+        p.add_argument("--dsn", required=True)
+        p.add_argument("--schema", default="lattice_brain")
+
+    docker = sub.add_parser("docker-plan")
+    docker.add_argument("--data-dir", type=Path, required=True)
+    docker.add_argument("--port", type=int, default=5432)
+
+    args = parser.parse_args()
+    if args.command == "docker-plan":
+        wizard = DockerPostgresWizard(args.data_dir, port=args.port)
+        result = wizard.start(consent=False)
+        _print_json(result)
+        return 0
+
+    migrator = SQLiteToPostgresMigrator(
+        args.sqlite,
+        PostgresEngine(args.dsn, schema=args.schema),
+    )
+    _print_json(migrator.migrate(dry_run=args.command == "plan"))
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

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);

package/scripts/wheel_smoke.py

@@ -33,6 +33,9 @@ REPO_ROOT = Path(__file__).resolve().parents[1]
 # Every importable module the wheel ships (pyproject py-modules + packages).
 WHEEL_MODULES = [
     "setup_wizard",
+    "lattice_brain",
+    "lattice_brain.storage",
+    "lattice_brain.archive",
     "latticeai",
     "latticeai.server_app",
     "latticeai.app_factory",