@gmickel/gno 2.3.2 → 2.4.0

package/spec/output-schemas/metadata-predicate.schema.json

@@ -0,0 +1,460 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "oneOf": [
+    {
+      "$ref": "#/definitions/__schema0"
+    },
+    {
+      "$ref": "#/definitions/__schema3"
+    },
+    {
+      "$ref": "#/definitions/__schema4"
+    },
+    {
+      "$ref": "#/definitions/__schema5"
+    },
+    {
+      "$ref": "#/definitions/__schema6"
+    },
+    {
+      "$ref": "#/definitions/__schema14"
+    }
+  ],
+  "definitions": {
+    "__schema0": {
+      "type": "object",
+      "properties": {
+        "op": {
+          "type": "string",
+          "enum": ["eq", "ne"]
+        },
+        "key": {
+          "$ref": "#/definitions/__schema1"
+        },
+        "value": {
+          "$ref": "#/definitions/__schema2"
+        }
+      },
+      "required": ["op", "key", "value"],
+      "additionalProperties": false
+    },
+    "__schema1": {
+      "type": "string",
+      "minLength": 1,
+      "maxLength": 128
+    },
+    "__schema2": {
+      "anyOf": [
+        {
+          "type": "string",
+          "maxLength": 4096
+        },
+        {
+          "type": "number"
+        },
+        {
+          "type": "boolean"
+        }
+      ]
+    },
+    "__schema3": {
+      "type": "object",
+      "properties": {
+        "op": {
+          "type": "string",
+          "enum": ["gt", "gte", "lt", "lte"]
+        },
+        "key": {
+          "$ref": "#/definitions/__schema1"
+        },
+        "value": {
+          "type": "number"
+        }
+      },
+      "required": ["op", "key", "value"],
+      "additionalProperties": false
+    },
+    "__schema4": {
+      "type": "object",
+      "properties": {
+        "op": {
+          "type": "string",
+          "enum": ["in", "nin", "all"]
+        },
+        "key": {
+          "$ref": "#/definitions/__schema1"
+        },
+        "values": {
+          "maxItems": 128,
+          "type": "array",
+          "items": {
+            "$ref": "#/definitions/__schema2"
+          }
+        }
+      },
+      "required": ["op", "key", "values"],
+      "additionalProperties": false
+    },
+    "__schema5": {
+      "type": "object",
+      "properties": {
+        "op": {
+          "type": "string",
+          "const": "exists"
+        },
+        "key": {
+          "$ref": "#/definitions/__schema1"
+        },
+        "value": {
+          "type": "boolean"
+        }
+      },
+      "required": ["op", "key", "value"],
+      "additionalProperties": false
+    },
+    "__schema6": {
+      "type": "object",
+      "properties": {
+        "op": {
+          "type": "string",
+          "enum": ["and", "or"]
+        },
+        "predicates": {
+          "minItems": 1,
+          "maxItems": 128,
+          "type": "array",
+          "items": {
+            "$ref": "#/definitions/__schema7"
+          }
+        }
+      },
+      "required": ["op", "predicates"],
+      "additionalProperties": false
+    },
+    "__schema7": {
+      "oneOf": [
+        {
+          "$ref": "#/definitions/__schema0"
+        },
+        {
+          "$ref": "#/definitions/__schema3"
+        },
+        {
+          "$ref": "#/definitions/__schema4"
+        },
+        {
+          "$ref": "#/definitions/__schema5"
+        },
+        {
+          "type": "object",
+          "properties": {
+            "op": {
+              "type": "string",
+              "enum": ["and", "or"]
+            },
+            "predicates": {
+              "minItems": 1,
+              "maxItems": 128,
+              "type": "array",
+              "items": {
+                "$ref": "#/definitions/__schema8"
+              }
+            }
+          },
+          "required": ["op", "predicates"],
+          "additionalProperties": false
+        },
+        {
+          "type": "object",
+          "properties": {
+            "op": {
+              "type": "string",
+              "const": "not"
+            },
+            "predicate": {
+              "$ref": "#/definitions/__schema8"
+            }
+          },
+          "required": ["op", "predicate"],
+          "additionalProperties": false
+        }
+      ]
+    },
+    "__schema8": {
+      "oneOf": [
+        {
+          "$ref": "#/definitions/__schema0"
+        },
+        {
+          "$ref": "#/definitions/__schema3"
+        },
+        {
+          "$ref": "#/definitions/__schema4"
+        },
+        {
+          "$ref": "#/definitions/__schema5"
+        },
+        {
+          "type": "object",
+          "properties": {
+            "op": {
+              "type": "string",
+              "enum": ["and", "or"]
+            },
+            "predicates": {
+              "minItems": 1,
+              "maxItems": 128,
+              "type": "array",
+              "items": {
+                "$ref": "#/definitions/__schema9"
+              }
+            }
+          },
+          "required": ["op", "predicates"],
+          "additionalProperties": false
+        },
+        {
+          "type": "object",
+          "properties": {
+            "op": {
+              "type": "string",
+              "const": "not"
+            },
+            "predicate": {
+              "$ref": "#/definitions/__schema9"
+            }
+          },
+          "required": ["op", "predicate"],
+          "additionalProperties": false
+        }
+      ]
+    },
+    "__schema9": {
+      "oneOf": [
+        {
+          "$ref": "#/definitions/__schema0"
+        },
+        {
+          "$ref": "#/definitions/__schema3"
+        },
+        {
+          "$ref": "#/definitions/__schema4"
+        },
+        {
+          "$ref": "#/definitions/__schema5"
+        },
+        {
+          "type": "object",
+          "properties": {
+            "op": {
+              "type": "string",
+              "enum": ["and", "or"]
+            },
+            "predicates": {
+              "minItems": 1,
+              "maxItems": 128,
+              "type": "array",
+              "items": {
+                "$ref": "#/definitions/__schema10"
+              }
+            }
+          },
+          "required": ["op", "predicates"],
+          "additionalProperties": false
+        },
+        {
+          "type": "object",
+          "properties": {
+            "op": {
+              "type": "string",
+              "const": "not"
+            },
+            "predicate": {
+              "$ref": "#/definitions/__schema10"
+            }
+          },
+          "required": ["op", "predicate"],
+          "additionalProperties": false
+        }
+      ]
+    },
+    "__schema10": {
+      "oneOf": [
+        {
+          "$ref": "#/definitions/__schema0"
+        },
+        {
+          "$ref": "#/definitions/__schema3"
+        },
+        {
+          "$ref": "#/definitions/__schema4"
+        },
+        {
+          "$ref": "#/definitions/__schema5"
+        },
+        {
+          "type": "object",
+          "properties": {
+            "op": {
+              "type": "string",
+              "enum": ["and", "or"]
+            },
+            "predicates": {
+              "minItems": 1,
+              "maxItems": 128,
+              "type": "array",
+              "items": {
+                "$ref": "#/definitions/__schema11"
+              }
+            }
+          },
+          "required": ["op", "predicates"],
+          "additionalProperties": false
+        },
+        {
+          "type": "object",
+          "properties": {
+            "op": {
+              "type": "string",
+              "const": "not"
+            },
+            "predicate": {
+              "$ref": "#/definitions/__schema11"
+            }
+          },
+          "required": ["op", "predicate"],
+          "additionalProperties": false
+        }
+      ]
+    },
+    "__schema11": {
+      "oneOf": [
+        {
+          "$ref": "#/definitions/__schema0"
+        },
+        {
+          "$ref": "#/definitions/__schema3"
+        },
+        {
+          "$ref": "#/definitions/__schema4"
+        },
+        {
+          "$ref": "#/definitions/__schema5"
+        },
+        {
+          "type": "object",
+          "properties": {
+            "op": {
+              "type": "string",
+              "enum": ["and", "or"]
+            },
+            "predicates": {
+              "minItems": 1,
+              "maxItems": 128,
+              "type": "array",
+              "items": {
+                "$ref": "#/definitions/__schema12"
+              }
+            }
+          },
+          "required": ["op", "predicates"],
+          "additionalProperties": false
+        },
+        {
+          "type": "object",
+          "properties": {
+            "op": {
+              "type": "string",
+              "const": "not"
+            },
+            "predicate": {
+              "$ref": "#/definitions/__schema12"
+            }
+          },
+          "required": ["op", "predicate"],
+          "additionalProperties": false
+        }
+      ]
+    },
+    "__schema12": {
+      "oneOf": [
+        {
+          "$ref": "#/definitions/__schema0"
+        },
+        {
+          "$ref": "#/definitions/__schema3"
+        },
+        {
+          "$ref": "#/definitions/__schema4"
+        },
+        {
+          "$ref": "#/definitions/__schema5"
+        },
+        {
+          "type": "object",
+          "properties": {
+            "op": {
+              "type": "string",
+              "enum": ["and", "or"]
+            },
+            "predicates": {
+              "minItems": 1,
+              "maxItems": 128,
+              "type": "array",
+              "items": {
+                "$ref": "#/definitions/__schema13"
+              }
+            }
+          },
+          "required": ["op", "predicates"],
+          "additionalProperties": false
+        },
+        {
+          "type": "object",
+          "properties": {
+            "op": {
+              "type": "string",
+              "const": "not"
+            },
+            "predicate": {
+              "$ref": "#/definitions/__schema13"
+            }
+          },
+          "required": ["op", "predicate"],
+          "additionalProperties": false
+        }
+      ]
+    },
+    "__schema13": {
+      "oneOf": [
+        {
+          "$ref": "#/definitions/__schema0"
+        },
+        {
+          "$ref": "#/definitions/__schema3"
+        },
+        {
+          "$ref": "#/definitions/__schema4"
+        },
+        {
+          "$ref": "#/definitions/__schema5"
+        }
+      ]
+    },
+    "__schema14": {
+      "type": "object",
+      "properties": {
+        "op": {
+          "type": "string",
+          "const": "not"
+        },
+        "predicate": {
+          "$ref": "#/definitions/__schema7"
+        }
+      },
+      "required": ["op", "predicate"],
+      "additionalProperties": false
+    }
+  },
+  "$id": "gno://schemas/metadata-predicate@1.0"
+}

package/spec/output-schemas/retrieval-trace-filters.schema.json

@@ -8,7 +8,9 @@
       "additionalProperties": false,
       "required": ["mode", "text"],
       "properties": {
-        "mode": { "enum": ["term", "intent", "hyde"] },
+        "mode": {
+          "enum": ["term", "intent", "hyde"]
+        },
         "text": { "type": "string", "maxLength": 8192 }
       }
     },
@@ -63,7 +65,10 @@
           "maxItems": 100,
           "items": { "$ref": "#/definitions/queryMode" }
         },
-        "uriPrefix": { "type": "string", "maxLength": 4096 }
+        "uriPrefix": { "type": "string", "maxLength": 4096 },
+        "filter": {
+          "$ref": "gno://schemas/metadata-predicate@1.0"
+        }
       }
     },
     "metadataShape": {
@@ -133,7 +138,11 @@
     }
   },
   "oneOf": [
-    { "$ref": "#/definitions/filters" },
-    { "$ref": "#/definitions/metadataFilters" }
+    {
+      "$ref": "#/definitions/filters"
+    },
+    {
+      "$ref": "#/definitions/metadataFilters"
+    }
   ]
 }

package/spec/output-schemas/search-results.schema.json

@@ -408,6 +408,18 @@
       "description": "Search metadata",
       "required": ["query", "mode", "totalResults"],
       "properties": {
+        "warnings": {
+          "type": "array",
+          "items": {
+            "type": "object",
+            "additionalProperties": false,
+            "required": ["code", "message"],
+            "properties": {
+              "code": { "type": "string" },
+              "message": { "type": "string" }
+            }
+          }
+        },
         "query": {
           "type": "string",
           "description": "Original search query"

package/spec/output-schemas/status.schema.json

@@ -35,19 +35,31 @@
         "pendingMirrors"
       ],
       "properties": {
-        "configured": { "$ref": "#/properties/chunking/definitions/params" },
+        "configured": {
+          "$ref": "#/properties/chunking/definitions/params"
+        },
         "applied": {
           "oneOf": [
-            { "$ref": "#/properties/chunking/definitions/params" },
-            { "type": "null" }
+            {
+              "$ref": "#/properties/chunking/definitions/params"
+            },
+            {
+              "type": "null"
+            }
           ]
         },
         "state": {
           "type": "string",
           "enum": ["empty", "legacy-default", "current", "pending", "mixed"]
         },
-        "pendingDocuments": { "type": "integer", "minimum": 0 },
-        "pendingMirrors": { "type": "integer", "minimum": 0 }
+        "pendingDocuments": {
+          "type": "integer",
+          "minimum": 0
+        },
+        "pendingMirrors": {
+          "type": "integer",
+          "minimum": 0
+        }
       },
       "definitions": {
         "params": {
@@ -60,7 +72,11 @@
               "minimum": 10,
               "maximum": 2251799813685247
             },
-            "overlapPercent": { "type": "number", "minimum": 0, "maximum": 0.5 }
+            "overlapPercent": {
+              "type": "number",
+              "minimum": 0,
+              "maximum": 0.5
+            }
           }
         }
       }
@@ -951,6 +967,21 @@
           }
         }
       }
+    },
+    "typedMetadata": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["pending", "invalid"],
+      "properties": {
+        "pending": {
+          "type": "integer",
+          "minimum": 0
+        },
+        "invalid": {
+          "type": "integer",
+          "minimum": 0
+        }
+      }
     }
   }
 }

package/src/app/context-runtime-contract.ts

@@ -154,7 +154,8 @@ export const projectContextCapsule = (
     egressLineage: ContextCapsulePayloadV1_1["egressLineage"];
   },
   input: NormalizedContextBuildInput,
-  deps: ContextCapsuleRuntimeDeps
+  deps: ContextCapsuleRuntimeDeps,
+  metadataCoverageIncomplete = false
 ): ContextCanonicalProjection<ContextCapsuleV1> | null => {
   if (draft.selection.selected.length === 0) return null;
   const evidence = draft.selection.selected.map((candidate, index) =>
@@ -286,7 +287,37 @@ export const projectContextCapsule = (
     ],
   };
   try {
-    const value = createContextCapsuleV1(payload, {
+    const versionedPayload =
+      input.filter === undefined
+        ? payload
+        : {
+            ...payload,
+            schemaVersion: "1.2" as const,
+            coverage: {
+              ...payload.coverage,
+              complete:
+                payload.coverage.complete && !metadataCoverageIncomplete,
+            },
+            warnings: [
+              ...payload.warnings,
+              ...(metadataCoverageIncomplete && payload.coverage.complete
+                ? [{ code: "incomplete_coverage" as const }]
+                : []),
+              ...(metadataCoverageIncomplete
+                ? [{ code: "metadata_coverage_incomplete" as const }]
+                : []),
+            ],
+            scope: { ...payload.scope, filter: input.filter },
+            retrieval: {
+              ...payload.retrieval,
+              request: { ...payload.retrieval.request, filter: input.filter },
+            },
+          };
+    versionedPayload.fingerprints.retrieval = retrievalFingerprint(
+      versionedPayload,
+      snapshots.contextFingerprint
+    );
+    const value = createContextCapsuleV1(versionedPayload, {
       countTokens: deps.countTokens,
     });
     return {

package/src/app/context-runtime-input.ts

@@ -5,6 +5,10 @@ import type { ContextCapsuleBuildInput } from "./context-runtime-types";
 
 import { isValidLanguageHint } from "../config/types";
 import { normalizeTag, validateTag } from "../core/tags";
+import {
+  metadataPredicateSchema,
+  normalizeMetadataPredicate,
+} from "../core/typed-metadata";
 import { resolveTemporalRange } from "../pipeline/temporal";
 import { buildUri, parseUri } from "./constants";
 import { ContextRuntimeError } from "./context-runtime-types";
@@ -355,8 +359,21 @@ export const normalizeContextBuildInput = (
       "Context author or language filter is invalid"
     );
   }
+  const parsedFilter =
+    input.filter === undefined
+      ? undefined
+      : metadataPredicateSchema.safeParse(input.filter);
+  if (parsedFilter && !parsedFilter.success) {
+    throw new ContextRuntimeError(
+      "invalid_filter",
+      `filter: ${parsedFilter.error.message}`
+    );
+  }
   return {
     ...input,
+    ...(parsedFilter?.success
+      ? { filter: normalizeMetadataPredicate(parsedFilter.data) }
+      : {}),
     goal,
     query,
     indexName,

package/src/app/context-runtime-types.ts

@@ -3,6 +3,7 @@ import type { ContextCapsuleV1 } from "../core/context-capsule";
 import type { ContextEvidenceCompilerDeps } from "../core/context-evidence";
 import type { ContextVerifierDeps } from "../core/context-verifier";
 import type { RetrievalTraceSession } from "../core/retrieval-trace-session";
+import type { MetadataPredicate } from "../core/typed-metadata";
 import type { EmbeddingPort, RerankPort } from "../llm/types";
 import type { RequestHydration } from "../pipeline/hydration";
 import type { ProjectAffinityScoringInput } from "../pipeline/project-affinity";
@@ -22,6 +23,7 @@ export interface ContextCapsuleBuildInput {
   tagsAll?: string[];
   tagsAny?: string[];
   categories?: string[];
+  filter?: MetadataPredicate;
   author?: string;
   lang?: string;
   intent?: string;