@intent-systems/nexus 2026.1.5-3

package/skills/json-render/scripts/llm-server/package.json

@@ -0,0 +1,18 @@
+{
+  "name": "json-render-llm-server",
+  "private": true,
+  "type": "module",
+  "description": "Local LLM server for streaming json-render patches.",
+  "scripts": {
+    "dev": "tsx server.ts"
+  },
+  "dependencies": {
+    "@ai-sdk/anthropic": "^3.0.15",
+    "@json-render/core": "^0.2.0",
+    "ai": "^6.0.39",
+    "zod": "^4.3.5"
+  },
+  "devDependencies": {
+    "tsx": "^4.21.0"
+  }
+}

package/skills/json-render/scripts/llm-server/server.ts

@@ -0,0 +1,285 @@
+import http from "node:http";
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { streamText } from "ai";
+import { anthropic } from "@ai-sdk/anthropic";
+import { generateCatalogPrompt } from "@json-render/core";
+import { catalog } from "./catalog";
+
+const PORT = Number(process.env.PORT ?? 8787);
+const MODEL = process.env.ANTHROPIC_MODEL ?? "claude-3-haiku-20240307";
+const ALLOW_ORIGIN = process.env.ALLOW_ORIGIN ?? "*";
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const DATA_PATH =
+  process.env.NEXUS_CORE_DATA_PATH ??
+  path.resolve(__dirname, "../../assets/demo/data/nexus-core.json");
+
+function readBody(req: http.IncomingMessage) {
+  return new Promise<string>((resolve, reject) => {
+    let data = "";
+    req.on("data", (chunk) => {
+      data += chunk;
+    });
+    req.on("end", () => resolve(data));
+    req.on("error", reject);
+  });
+}
+
+function withCors(res: http.ServerResponse) {
+  res.setHeader("Access-Control-Allow-Origin", ALLOW_ORIGIN);
+  res.setHeader("Access-Control-Allow-Methods", "POST, OPTIONS");
+  res.setHeader("Access-Control-Allow-Headers", "Content-Type");
+}
+
+function loadNexusCoreData() {
+  try {
+    if (!fs.existsSync(DATA_PATH)) {
+      return null;
+    }
+    return JSON.parse(fs.readFileSync(DATA_PATH, "utf8"));
+  } catch {
+    return null;
+  }
+}
+
+const server = http.createServer(async (req, res) => {
+  withCors(res);
+
+  if (req.method === "OPTIONS") {
+    res.writeHead(204);
+    res.end();
+    return;
+  }
+
+  if (req.method !== "POST" || req.url !== "/api/generate") {
+    res.writeHead(404, { "Content-Type": "application/json" });
+    res.end(JSON.stringify({ error: "Not found" }));
+    return;
+  }
+
+  if (!process.env.ANTHROPIC_API_KEY) {
+    res.writeHead(400, { "Content-Type": "application/json" });
+    res.end(
+      JSON.stringify({ error: "ANTHROPIC_API_KEY is required to run the LLM." }),
+    );
+    return;
+  }
+
+  try {
+    const rawBody = await readBody(req);
+    const payload = rawBody ? JSON.parse(rawBody) : {};
+    const prompt = String(payload.prompt ?? "").trim();
+    const currentTree = payload.currentTree;
+    const contextPayload = payload.context;
+
+    if (!prompt) {
+      res.writeHead(400, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ error: "Prompt is required." }));
+      return;
+    }
+
+    const baseSystem = generateCatalogPrompt(catalog);
+    const extraGuidance = [
+      "Use DataTable or KeyValueList when rendering arbitrary data.",
+      "Do not invent components that are not in the catalog.",
+      "Keep trees shallow and prefer composed sections.",
+      "Respond ONLY with newline-delimited JSON patch objects (one per line).",
+      "Each patch is {\"op\":\"set|add|replace|remove\",\"path\":\"/root|/elements/...\",\"value\":...}.",
+      "Set the root with {\"op\":\"replace\",\"path\":\"/root\",\"value\":\"root\"}.",
+      "Create/update elements with {\"op\":\"set\",\"path\":\"/elements/<key>\",\"value\":{...}}.",
+      "Elements must include: key, type, props, children (array of keys), visible (optional).",
+      "Never inline child element objects inside children; define each element separately.",
+      "Always define a root element at /elements/root that references child keys.",
+      "DataTable props: { title?: string, columns: string[], rows: string[][] }.",
+      "KeyValueList props: { title?: string, items: { label: string, value: string }[] }.",
+      "Never wrap the response in markdown or code fences.",
+    ].join("\n");
+
+    const wantsData =
+      prompt.includes("data") ||
+      prompt.includes("table") ||
+      prompt.includes("metrics") ||
+      prompt.includes("stats") ||
+      prompt.includes("registry");
+    const dataPayload = wantsData ? loadNexusCoreData() : null;
+    const dataBlock = dataPayload
+      ? `Nexus core data (from agent hook):\n${JSON.stringify(dataPayload)}`
+      : "";
+
+    const treeContext = contextPayload?.currentTree ?? currentTree;
+    const contextBlock = contextPayload
+      ? `Context:\n${JSON.stringify(contextPayload)}`
+      : "";
+    const treeBlock = treeContext
+      ? `Current UI tree:\n${JSON.stringify(treeContext)}`
+      : "";
+
+    const result = streamText({
+      model: anthropic(MODEL),
+      system: `${baseSystem}\n\n${extraGuidance}`,
+      prompt: [
+        contextBlock,
+        treeBlock,
+        dataBlock,
+        `User request:\n${prompt}`,
+      ]
+        .filter(Boolean)
+        .join("\n\n"),
+    });
+
+    res.writeHead(200, { "Content-Type": "text/plain; charset=utf-8" });
+    let buffer = "";
+    let rawOutput = "";
+    let collecting = false;
+    let depth = 0;
+    let inString = false;
+    let escaped = false;
+    let jsonStart = -1;
+    let didFlush = false;
+    const extractJsonObjects = (text: string) => {
+      const results: unknown[] = [];
+      let collectingLocal = false;
+      let depthLocal = 0;
+      let inStringLocal = false;
+      let escapedLocal = false;
+      let jsonStartLocal = -1;
+      let i = 0;
+      while (i < text.length) {
+        const char = text[i];
+        if (!collectingLocal) {
+          if (char === "{") {
+            collectingLocal = true;
+            depthLocal = 1;
+            inStringLocal = false;
+            escapedLocal = false;
+            jsonStartLocal = i;
+          }
+          i += 1;
+          continue;
+        }
+
+        if (inStringLocal) {
+          if (escapedLocal) {
+            escapedLocal = false;
+          } else if (char === "\\") {
+            escapedLocal = true;
+          } else if (char === "\"") {
+            inStringLocal = false;
+          }
+          i += 1;
+          continue;
+        }
+
+        if (char === "\"") {
+          inStringLocal = true;
+        } else if (char === "{") {
+          depthLocal += 1;
+        } else if (char === "}") {
+          depthLocal -= 1;
+          if (depthLocal === 0 && jsonStartLocal >= 0) {
+            const jsonText = text.slice(jsonStartLocal, i + 1);
+            try {
+              results.push(JSON.parse(jsonText));
+            } catch {
+              // Skip invalid JSON blocks
+            }
+            collectingLocal = false;
+            jsonStartLocal = -1;
+          }
+        }
+        i += 1;
+      }
+      return results;
+    };
+
+    const flushJson = (jsonText: string) => {
+      try {
+        const parsed = JSON.parse(jsonText);
+        res.write(`${JSON.stringify(parsed)}\n`);
+        didFlush = true;
+      } catch {
+        // Ignore malformed chunks
+      }
+    };
+
+    for await (const chunk of result.textStream) {
+      rawOutput += chunk;
+      buffer += chunk;
+      let i = 0;
+      while (i < buffer.length) {
+        const char = buffer[i];
+        if (!collecting) {
+          if (char === "{") {
+            collecting = true;
+            depth = 1;
+            inString = false;
+            escaped = false;
+            jsonStart = i;
+          }
+          i += 1;
+          continue;
+        }
+
+        if (inString) {
+          if (escaped) {
+            escaped = false;
+          } else if (char === "\\") {
+            escaped = true;
+          } else if (char === "\"") {
+            inString = false;
+          }
+          i += 1;
+          continue;
+        }
+
+        if (char === "\"") {
+          inString = true;
+        } else if (char === "{") {
+          depth += 1;
+        } else if (char === "}") {
+          depth -= 1;
+          if (depth === 0 && jsonStart >= 0) {
+            const jsonText = buffer.slice(jsonStart, i + 1);
+            flushJson(jsonText);
+            buffer = buffer.slice(i + 1);
+            i = 0;
+            collecting = false;
+            jsonStart = -1;
+            continue;
+          }
+        }
+        i += 1;
+      }
+    }
+    if (!didFlush) {
+      const fallback = extractJsonObjects(rawOutput);
+      if (fallback.length) {
+        for (const patch of fallback) {
+          res.write(`${JSON.stringify(patch)}\n`);
+        }
+        didFlush = true;
+      } else {
+        const preview = rawOutput.trim().slice(0, 2000);
+        if (preview) {
+          console.warn("LLM output (no JSON detected):", preview);
+        } else {
+          console.warn("LLM output was empty.");
+        }
+      }
+    }
+    res.end();
+  } catch (error) {
+    res.writeHead(500, { "Content-Type": "application/json" });
+    res.end(
+      JSON.stringify({
+        error: error instanceof Error ? error.message : "Server error",
+      }),
+    );
+  }
+});
+
+server.listen(PORT, () => {
+  console.log(`LLM server ready at http://localhost:${PORT}/api/generate`);
+});

package/skills/local-places/SERVER_README.md

@@ -0,0 +1,101 @@
+# Local Places
+
+This repo is a fusion of two pieces:
+
+- A FastAPI server that exposes endpoints for searching and resolving places via the Google Maps Places API.
+- A companion agent skill that explains how to use the API and can call it to find places efficiently.
+
+Together, the skill and server let an agent turn natural-language place queries into structured results quickly.
+
+## Run locally
+
+```bash
+# copy skill definition into the relevant folder (where the agent looks for it)
+# then run the server
+
+uv venv
+uv pip install -e ".[dev]"
+uv run --env-file .env uvicorn local_places.main:app --host 0.0.0.0 --reload
+```
+
+Open the API docs at http://127.0.0.1:8000/docs.
+
+## Places API
+
+Set the Google Places API key before running:
+
+```bash
+export GOOGLE_PLACES_API_KEY="your-key"
+```
+
+Endpoints:
+
+- `POST /places/search` (free-text query + filters)
+- `GET /places/{place_id}` (place details)
+- `POST /locations/resolve` (resolve a user-provided location string)
+
+Example search request:
+
+```json
+{
+  "query": "italian restaurant",
+  "filters": {
+    "types": ["restaurant"],
+    "open_now": true,
+    "min_rating": 4.0,
+    "price_levels": [1, 2]
+  },
+  "limit": 10
+}
+```
+
+Notes:
+
+- `filters.types` supports a single type (mapped to Google `includedType`).
+
+Example search request (curl):
+
+```bash
+curl -X POST http://127.0.0.1:8000/places/search \
+  -H "Content-Type: application/json" \
+  -d '{
+    "query": "italian restaurant",
+    "location_bias": {
+      "lat": 40.8065,
+      "lng": -73.9719,
+      "radius_m": 3000
+    },
+    "filters": {
+      "types": ["restaurant"],
+      "open_now": true,
+      "min_rating": 4.0,
+      "price_levels": [1, 2, 3]
+    },
+    "limit": 10
+  }'
+```
+
+Example resolve request (curl):
+
+```bash
+curl -X POST http://127.0.0.1:8000/locations/resolve \
+  -H "Content-Type: application/json" \
+  -d '{
+    "location_text": "Riverside Park, New York",
+    "limit": 5
+  }'
+```
+
+## Test
+
+```bash
+uv run pytest
+```
+
+## OpenAPI
+
+Generate the OpenAPI schema:
+
+```bash
+uv run python scripts/generate_openapi.py
+```

package/skills/local-places/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: local-places
+description: Search for places (restaurants, cafes, etc.) via Google Places API proxy on localhost.
+homepage: https://github.com/Hyaxia/local_places
+metadata: {"nexus":{"emoji":"📍","requires":{"bins":["uv"],"env":["GOOGLE_PLACES_API_KEY"]},"primaryEnv":"GOOGLE_PLACES_API_KEY"}}
+---
+
+# 📍 Local Places
+
+*Find places, Go fast*
+
+Search for nearby places using a local Google Places API proxy. Two-step flow: resolve location first, then search.
+
+## Setup
+
+```bash
+cd {baseDir}
+echo "GOOGLE_PLACES_API_KEY=your-key" > .env
+uv venv && uv pip install -e ".[dev]"
+uv run --env-file .env uvicorn local_places.main:app --host 127.0.0.1 --port 8000
+```
+
+Requires `GOOGLE_PLACES_API_KEY` in `.env` or environment.
+
+## Quick Start
+
+1. **Check server:** `curl http://127.0.0.1:8000/ping`
+
+2. **Resolve location:**
+```bash
+curl -X POST http://127.0.0.1:8000/locations/resolve \
+  -H "Content-Type: application/json" \
+  -d '{"location_text": "Soho, London", "limit": 5}'
+```
+
+3. **Search places:**
+```bash
+curl -X POST http://127.0.0.1:8000/places/search \
+  -H "Content-Type: application/json" \
+  -d '{
+    "query": "coffee shop",
+    "location_bias": {"lat": 51.5137, "lng": -0.1366, "radius_m": 1000},
+    "filters": {"open_now": true, "min_rating": 4.0},
+    "limit": 10
+  }'
+```
+
+4. **Get details:**
+```bash
+curl http://127.0.0.1:8000/places/{place_id}
+```
+
+## Conversation Flow
+
+1. If user says "near me" or gives vague location → resolve it first
+2. If multiple results → show numbered list, ask user to pick
+3. Ask for preferences: type, open now, rating, price level
+4. Search with `location_bias` from chosen location
+5. Present results with name, rating, address, open status
+6. Offer to fetch details or refine search
+
+## Filter Constraints
+
+- `filters.types`: exactly ONE type (e.g., "restaurant", "cafe", "gym")
+- `filters.price_levels`: integers 0-4 (0=free, 4=very expensive)
+- `filters.min_rating`: 0-5 in 0.5 increments
+- `filters.open_now`: boolean
+- `limit`: 1-20 for search, 1-10 for resolve
+- `location_bias.radius_m`: must be > 0
+
+## Response Format
+
+```json
+{
+  "results": [
+    {
+      "place_id": "ChIJ...",
+      "name": "Coffee Shop",
+      "address": "123 Main St",
+      "location": {"lat": 51.5, "lng": -0.1},
+      "rating": 4.6,
+      "price_level": 2,
+      "types": ["cafe", "food"],
+      "open_now": true
+    }
+  ],
+  "next_page_token": "..." 
+}
+```
+
+Use `next_page_token` as `page_token` in next request for more results.

package/skills/local-places/pyproject.toml

@@ -0,0 +1,27 @@
+[project]
+name = "my-api"
+version = "0.1.0"
+description = "FastAPI server"
+readme = "README.md"
+requires-python = ">=3.11"
+dependencies = [
+  "fastapi>=0.110.0",
+  "httpx>=0.27.0",
+  "uvicorn[standard]>=0.29.0",
+]
+
+[project.optional-dependencies]
+dev = [
+  "pytest>=8.0.0",
+]
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/local_places"]
+
+[tool.pytest.ini_options]
+addopts = "-q"
+testpaths = ["tests"]

package/skills/local-places/src/local_places/__init__.py

@@ -0,0 +1,2 @@
+__all__ = ["__version__"]
+__version__ = "0.1.0"