@gmickel/gno 2.3.3 → 2.5.1

package/src/sdk/index.ts

@@ -80,6 +80,10 @@ export type {
   SectionTargetCreateSelector,
   SectionTargetResolveResult,
   SectionTargetV1,
+  MetadataPredicate,
+  MetadataScalar,
+  TypedMetadata,
+  TypedValue,
   MemoryCandidate,
   MemoryFact,
   MemoryRecallReceipt,
@@ -124,3 +128,10 @@ export type {
   RetrievalTracePurgeResult,
   RetrievalTraceSummary,
 } from "../core/retrieval-trace-management";
+
+export type {
+  CompiledContextPreviewInput,
+  CompiledContextCheckInput,
+  CompiledContextPreview,
+  CompiledContextCheck,
+} from "../core/compiled-context";

package/src/sdk/types.ts

@@ -1,9 +1,17 @@
+import type {
+  previewCompiledContext,
+  checkCompiledContext,
+} from "../app/compiled-context";
+import type {
+  compileContextFile,
+  checkContextFile,
+  refreshContextFile,
+} from "../app/compiled-context-files";
 /**
  * Public SDK types.
  *
  * @module src/sdk/types
  */
-
 import type {
   ContextCapsuleBuildInput,
   ContextRuntimeErrorCode,
@@ -18,6 +26,10 @@ import type {
   CollectionEgressPolicyState,
   EgressRelaxationConfirmation,
 } from "../core/collection-egress-policy-service";
+import type {
+  CompiledContextPreviewInput,
+  CompiledContextCheckInput,
+} from "../core/compiled-context";
 import type {
   ContextCapsuleErrorCode,
   ContextCapsuleV1,
@@ -328,6 +340,21 @@ export interface GnoClient {
   query(query: string, options?: GnoQueryOptions): Promise<SearchResults>;
   ask(query: string, options?: GnoAskOptions): Promise<AskResult>;
   context(input: GnoContextInput): Promise<GnoContextResult>;
+  compiledContextPreview(
+    input: CompiledContextPreviewInput
+  ): ReturnType<typeof previewCompiledContext>;
+  compiledContextCheck(
+    input: CompiledContextCheckInput
+  ): ReturnType<typeof checkCompiledContext>;
+  compileContextFile(
+    input: Parameters<typeof compileContextFile>[0]
+  ): ReturnType<typeof compileContextFile>;
+  checkContextFile(
+    input: Parameters<typeof checkContextFile>[0]
+  ): ReturnType<typeof checkContextFile>;
+  refreshContextFile(
+    input: Parameters<typeof refreshContextFile>[0]
+  ): ReturnType<typeof refreshContextFile>;
   verifyContext(
     capsule: ContextCapsuleV1
   ): Promise<GnoContextVerificationResult>;
@@ -435,3 +462,10 @@ export interface GnoClient {
   ): Promise<SectionTargetResolveResult>;
   close(): Promise<void>;
 }
+
+export type {
+  MetadataPredicate,
+  MetadataScalar,
+  TypedMetadata,
+  TypedValue,
+} from "../core/typed-metadata";

package/src/serve/compiled-context.ts

@@ -0,0 +1,84 @@
+import type { ServerContext } from "./context";
+
+/** Read-only compiled context adapters; caller authority comes from the socket. */
+import {
+  previewCompiledContext,
+  checkCompiledContext,
+} from "../app/compiled-context";
+import {
+  compiledContextPreviewInputSchema,
+  compiledContextCheckInputSchema,
+} from "../core/compiled-context";
+import {
+  isLocalClientRequest,
+  type RequestPeerServer,
+} from "./request-locality";
+
+export async function handleCompiledContext(
+  context: ServerContext,
+  request: Request,
+  server: RequestPeerServer | undefined,
+  operation: "preview" | "check"
+): Promise<Response> {
+  try {
+    // Bound bytes before JSON parsing, even when Content-Length is absent.
+    const reader = request.body?.getReader();
+    if (!reader)
+      return Response.json(
+        { error: { code: "invalid_input", message: "JSON body required" } },
+        { status: 400 }
+      );
+    const chunks: Uint8Array[] = [];
+    let size = 0;
+    while (true) {
+      const part = await reader.read();
+      if (part.done) break;
+      size += part.value.byteLength;
+      if (size > 8 * 1024 * 1024 + 65536) {
+        await reader.cancel();
+        return Response.json(
+          {
+            error: {
+              code: "invalid_input",
+              message: "Compiled context request exceeds byte limit",
+            },
+          },
+          { status: 413 }
+        );
+      }
+      chunks.push(part.value);
+    }
+    const raw: unknown = JSON.parse(
+      await new Blob(chunks.map((chunk) => new Uint8Array(chunk))).text()
+    );
+    const input =
+      operation === "preview"
+        ? compiledContextPreviewInputSchema.parse(raw)
+        : compiledContextCheckInputSchema.parse(raw);
+    const local = isLocalClientRequest(request, server);
+    const deps = {
+      store: context.store,
+      config: context.config,
+      indexName: context.indexName,
+      destinationZone: local ? ("local_process" as const) : ("remote" as const),
+      caller: { authenticated: local, operationAuthorized: true },
+    };
+    const result =
+      operation === "preview"
+        ? await previewCompiledContext(input, deps)
+        : await checkCompiledContext(input, deps);
+    return Response.json(result);
+  } catch {
+    // Supplied Capsules may contain private metadata; errors never echo inputs.
+    return Response.json(
+      {
+        error: {
+          code: "compiled_context_unavailable",
+          message:
+            "Compiled context is invalid, stale, or unavailable for this caller",
+        },
+      },
+      { status: 400 }
+    );
+  }
+}

package/src/serve/context-capsule.ts

@@ -126,6 +126,7 @@ export const handleContextBuild = async (
         since: input.since,
         until: input.until,
         categories: input.categories,
+        filter: input.filter,
         author: input.author,
         graph: input.graph,
         candidateLimit: input.candidateLimit,

package/src/serve/public/app.tsx

@@ -47,6 +47,7 @@ const Collections = lazy(() => import("./pages/Collections"));
 const Connectors = lazy(() => import("./pages/Connectors"));
 const Ask = lazy(() => import("./pages/Ask"));
 const GraphView = lazy(() => import("./pages/GraphView"));
+const CompiledContext = lazy(() => import("./pages/CompiledContext"));
 const TraceHistory = lazy(() => import("./pages/TraceHistory"));
 
 type Route =
@@ -59,6 +60,7 @@ type Route =
   | "/collections"
   | "/graph"
   | "/connectors"
+  | "/context/compiled"
   | "/traces";
 type Navigate = (to: string | number) => void;
 
@@ -78,6 +80,7 @@ const routes: Record<Route, React.ComponentType<RoutePageProps>> = {
   "/ask": Ask,
   "/graph": GraphView,
   "/traces": TraceHistory,
+  "/context/compiled": CompiledContext,
 };
 
 interface AppContentProps {
@@ -179,7 +182,7 @@ function AppContent({
           <div className="ornament mx-auto mb-4 max-w-[8rem] text-muted-foreground/20">
             <span className="text-[10px]">◆</span>
           </div>
-          <div className="flex items-center justify-center gap-5 text-muted-foreground/60">
+          <div className="flex flex-wrap items-center justify-center gap-x-3 gap-y-2 px-4 text-muted-foreground/60 sm:gap-x-5">
             <button
               className="transition-colors duration-300 hover:text-primary"
               onClick={() => navigate("/collections")}
@@ -196,6 +199,14 @@ function AppContent({
               Trace history
             </button>
             <span className="text-border/30">—</span>
+            <button
+              className="transition-colors duration-300 hover:text-primary"
+              onClick={() => navigate("/context/compiled")}
+              type="button"
+            >
+              Compiled context
+            </button>
+            <span className="text-border/30">—</span>
             <a
               className="transition-colors duration-300 hover:text-primary"
               href="https://github.com/gmickel/gno"

package/src/serve/public/components/MetadataFilter.tsx

@@ -0,0 +1,186 @@
+import { useId, useState } from "react";
+
+import { parseMetadataFilter } from "../lib/metadata-filter";
+import { Button } from "./ui/button";
+import { Input } from "./ui/input";
+import { Textarea } from "./ui/textarea";
+
+const OPERATORS = [
+  "eq",
+  "ne",
+  "gt",
+  "gte",
+  "lt",
+  "lte",
+  "in",
+  "nin",
+  "all",
+  "exists",
+];
+
+/** The JSON text is the single source of truth, including invalid drafts. */
+export function MetadataFilter({
+  value,
+  onChange,
+}: {
+  value: string;
+  onChange: (value: string) => void;
+}) {
+  const id = useId();
+  const [draftValue, setDraftValue] = useState<string | null>(null);
+  const [draftLeaf, setDraftLeaf] = useState<Record<string, unknown> | null>(
+    null
+  );
+  const { error } = parseMetadataFilter(value);
+  let leaf: Record<string, unknown> | null = null;
+  try {
+    const parsed: unknown = JSON.parse(value);
+    if (
+      parsed &&
+      typeof parsed === "object" &&
+      !Array.isArray(parsed) &&
+      "op" in parsed &&
+      OPERATORS.includes(String(parsed.op))
+    )
+      leaf = parsed as Record<string, unknown>;
+  } catch {
+    /* Invalid JSON stays editable below. */
+  }
+  if (value.trim()) leaf ??= draftLeaf;
+  const update = (patch: Record<string, unknown>) => {
+    const next = { ...leaf, ...patch };
+    setDraftLeaf(next);
+    if (draftValue !== null) {
+      const property = "values" in next ? "values" : "value";
+      onChange(
+        `{"op":${JSON.stringify(next.op)},"key":${JSON.stringify(next.key)},"${property}":${draftValue}}`
+      );
+    } else onChange(JSON.stringify(next));
+  };
+  return (
+    <fieldset className="min-w-0 space-y-3 border-border/40 border-t pt-3">
+      <legend className="px-1 font-mono text-muted-foreground text-xs">
+        Custom metadata
+      </legend>
+      <p className="text-muted-foreground text-xs">
+        Filter indexed gno.metadata fields. Text is case-sensitive. Values use
+        JSON: "approved", 0.8, true, or ["alpha"]. Filters are included in this
+        page’s URL.
+      </p>
+      {leaf ? (
+        <div className="grid min-w-0 gap-2 sm:grid-cols-3">
+          <label className="space-y-1 text-xs">
+            Field
+            <Input
+              onChange={(e) => update({ key: e.target.value })}
+              value={typeof leaf.key === "string" ? leaf.key : ""}
+            />
+          </label>
+          <label className="space-y-1 text-xs">
+            Operator
+            <select
+              className="h-9 w-full cursor-pointer rounded-md border border-input bg-background px-2 focus-visible:ring-2 focus-visible:ring-primary/50"
+              onChange={(e) => {
+                setDraftValue(null);
+                setDraftLeaf(null);
+                const op = e.target.value;
+                onChange(
+                  JSON.stringify({
+                    op,
+                    key: leaf?.key ?? "",
+                    ...(["in", "nin", "all"].includes(op)
+                      ? { values: [] }
+                      : { value: op === "exists" ? true : "" }),
+                  })
+                );
+              }}
+              value={String(leaf.op)}
+            >
+              {OPERATORS.map((op) => (
+                <option key={op} value={op}>
+                  {op}
+                </option>
+              ))}
+            </select>
+          </label>
+          <label className="space-y-1 text-xs">
+            Value (JSON)
+            <Input
+              onChange={(e) => {
+                const raw = e.target.value;
+                setDraftValue(raw);
+                setDraftLeaf(leaf);
+                const property = ["in", "nin", "all"].includes(String(leaf?.op))
+                  ? "values"
+                  : "value";
+                // Preserve malformed JSON verbatim for correction; never drop the filter.
+                onChange(
+                  `{"op":${JSON.stringify(leaf?.op)},"key":${JSON.stringify(leaf?.key ?? "")},"${property}":${raw}}`
+                );
+              }}
+              value={
+                draftValue ??
+                JSON.stringify("values" in leaf ? leaf.values : leaf.value) ??
+                ""
+              }
+            />
+          </label>
+        </div>
+      ) : !value.trim() ? (
+        <Button
+          onClick={() => {
+            setDraftValue(null);
+            setDraftLeaf(null);
+            onChange(
+              JSON.stringify({ op: "eq", key: "status", value: "approved" })
+            );
+          }}
+          size="sm"
+          type="button"
+          variant="outline"
+        >
+          Add metadata filter
+        </Button>
+      ) : null}
+      <label className="block space-y-1 text-xs" htmlFor={`${id}-json`}>
+        Advanced filter (JSON)
+        <Textarea
+          aria-describedby={error ? `${id}-error` : undefined}
+          aria-invalid={Boolean(error)}
+          className="min-h-20 font-mono text-xs"
+          id={`${id}-json`}
+          onChange={(e) => {
+            setDraftValue(null);
+            setDraftLeaf(null);
+            onChange(e.target.value);
+          }}
+          placeholder='{"op":"gte","key":"confidence","value":0.8}'
+          value={value}
+        />
+      </label>
+      {error && (
+        <p
+          className="break-words text-destructive text-xs"
+          id={`${id}-error`}
+          role="alert"
+        >
+          {error}
+        </p>
+      )}
+      {value && (
+        <Button
+          onClick={() => {
+            setDraftValue(null);
+            setDraftLeaf(null);
+            onChange("");
+          }}
+          size="sm"
+          type="button"
+          variant="ghost"
+        >
+          Clear metadata filter
+        </Button>
+      )}
+    </fieldset>
+  );
+}