@gmickel/gno 2.3.2 → 2.4.0

package/src/store/sqlite/adapter.ts

@@ -141,6 +141,10 @@ import {
 import { buildWikiBestMatchSubquery } from "../../core/graph-resolver";
 import { buildContentPrefilterNeedles } from "../../core/link-relevance";
 import { normalizeWikiName, stripWikiMdExt } from "../../core/links";
+import {
+  TYPED_METADATA_INGEST_VERSION,
+  typedMetadataSchema,
+} from "../../core/typed-metadata";
 import {
   parseActivationReceipt,
   serializeActivationReceipt,
@@ -1427,6 +1431,30 @@ export class SqliteAdapter implements StorePort, SqliteDbProvider {
   // Documents
   // ─────────────────────────────────────────────────────────────────────────
 
+  async getTypedMetadataCoverage(
+    options: import("../types").DocumentEligibilityOptions
+  ): Promise<StoreResult<{ pending: number; invalid: number }>> {
+    try {
+      const db = this.ensureOpen();
+      const eligible = buildEligibleDocumentQuery(
+        { ...options, filter: undefined },
+        db
+      );
+      const row = db
+        .query<{ pending: number; invalid: number }, (string | number)[]>(`
+        SELECT COALESCE(SUM(CASE WHEN d.ingest_version IS NULL OR d.ingest_version < ${TYPED_METADATA_INGEST_VERSION} OR (d.typed_metadata IS NULL AND d.metadata_error IS NULL) THEN 1 ELSE 0 END),0) AS pending,
+        COALESCE(SUM(CASE WHEN d.metadata_error IS NOT NULL THEN 1 ELSE 0 END),0) AS invalid
+        FROM documents d WHERE d.mirror_hash IS NOT NULL AND d.id IN (SELECT id FROM (${eligible.sql}))
+      `)
+        .get(...eligible.params);
+      return ok(row ?? { pending: 0, invalid: 0 });
+    } catch (cause) {
+      return err("QUERY_FAILED", "Cannot determine typed metadata coverage", {
+        cause,
+      });
+    }
+  }
+
   async upsertDocument(
     doc: DocumentInput
   ): Promise<StoreResult<UpsertDocumentResult>> {
@@ -1457,13 +1485,13 @@ export class SqliteAdapter implements StorePort, SqliteDbProvider {
           collection, rel_path, source_hash, source_mime, source_ext,
           source_size, source_mtime, source_ctime, docid, uri, title, mirror_hash,
           converter_id, converter_version, language_hint, content_type, categories,
-          content_type_source, author, frontmatter_date, date_fields,
+          content_type_source, author, frontmatter_date, date_fields, typed_metadata, metadata_error,
           record_key, record_source_path, record_source_locator, record_metadata, record_anchors,
           record_adapter_fingerprint,
           content_type_rules_fingerprint,
           active, indexed_at, last_error_code, last_error_message, last_error_at,
           ingest_version, updated_at
-        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 1, datetime('now'), ?, ?, ?, ?, datetime('now'))
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 1, datetime('now'), ?, ?, ?, ?, datetime('now'))
         ON CONFLICT(collection, rel_path) DO UPDATE SET
           source_hash = excluded.source_hash,
           source_mime = excluded.source_mime,
@@ -1484,6 +1512,8 @@ export class SqliteAdapter implements StorePort, SqliteDbProvider {
           author = excluded.author,
           frontmatter_date = excluded.frontmatter_date,
           date_fields = excluded.date_fields,
+          typed_metadata = excluded.typed_metadata,
+          metadata_error = excluded.metadata_error,
           record_key = excluded.record_key,
           record_source_path = excluded.record_source_path,
           record_source_locator = excluded.record_source_locator,
@@ -1521,6 +1551,10 @@ export class SqliteAdapter implements StorePort, SqliteDbProvider {
             doc.author ?? null,
             doc.frontmatterDate ?? null,
             doc.dateFields ? JSON.stringify(doc.dateFields) : null,
+            doc.typedMetadata
+              ? JSON.stringify(typedMetadataSchema.parse(doc.typedMetadata))
+              : null,
+            doc.metadataError ?? null,
             doc.recordKey ?? null,
             doc.recordSourcePath ?? null,
             doc.recordSourceLocator ?? null,
@@ -2109,6 +2143,7 @@ export class SqliteAdapter implements StorePort, SqliteDbProvider {
     options: {
       collection?: string;
       activeOnly?: boolean;
+      eligibility?: import("../types").DocumentEligibilityOptions;
     } = {}
   ): Promise<StoreResult<DocumentRow[]>> {
     try {
@@ -2131,7 +2166,7 @@ export class SqliteAdapter implements StorePort, SqliteDbProvider {
         const batch = uniqueDocids.slice(i, i + SQL_PARAM_LIMIT);
         const placeholders = batch.map(() => "?").join(",");
         const clauses = [`docid IN (${placeholders})`];
-        const params: string[] = [...batch];
+        const params: (string | number)[] = [...batch];
 
         if (options.activeOnly ?? true) {
           clauses.push("active = 1");
@@ -2141,8 +2176,15 @@ export class SqliteAdapter implements StorePort, SqliteDbProvider {
           params.push(options.collection);
         }
 
+        if (options.eligibility) {
+          const eligible = buildEligibleDocumentQuery(options.eligibility, db);
+          clauses.push(`id IN (SELECT id FROM (${eligible.sql}))`);
+          params.push(...eligible.params);
+        }
         const sql = `SELECT * FROM documents WHERE ${clauses.join(" AND ")} ORDER BY id`;
-        rows.push(...db.query<DbDocumentRow, string[]>(sql).all(...params));
+        rows.push(
+          ...db.query<DbDocumentRow, (string | number)[]>(sql).all(...params)
+        );
       }
 
       return ok(rows.map(mapDocumentRow));
@@ -5960,7 +6002,10 @@ export class SqliteAdapter implements StorePort, SqliteDbProvider {
       const recentErrors = recentErrorsRow?.count ?? 0;
       const healthy = recentErrors === 0;
 
+      const metadataCoverage = await this.getTypedMetadataCoverage({});
+      if (!metadataCoverage.ok) return metadataCoverage;
       return ok({
+        typedMetadata: metadataCoverage.value,
         version,
         indexName,
         configPath: this.configPath,
@@ -6286,6 +6331,8 @@ interface DbDocumentRow {
   author: string | null;
   frontmatter_date: string | null;
   date_fields: string | null;
+  typed_metadata: string | null;
+  metadata_error: string | null;
   record_key: string | null;
   record_source_path: string | null;
   record_source_locator: string | null;
@@ -6454,6 +6501,10 @@ function mapDocumentRow(row: DbDocumentRow): DocumentRow {
     author: row.author,
     frontmatterDate: row.frontmatter_date,
     dateFields,
+    typedMetadata: row.typed_metadata
+      ? typedMetadataSchema.parse(JSON.parse(row.typed_metadata))
+      : null,
+    metadataError: row.metadata_error,
     recordKey: row.record_key,
     recordSourcePath: row.record_source_path,
     recordSourceLocator: row.record_source_locator,

package/src/store/sqlite/eligibility.ts

@@ -2,7 +2,9 @@ import type { Database } from "bun:sqlite";
 
 import type { DocumentEligibilityOptions } from "../types";
 
+import { TYPED_METADATA_INGEST_VERSION } from "../../core/typed-metadata";
 import { matchesExcludedText } from "../../pipeline/exclude";
+import { compileMetadataPredicate } from "./metadata-predicate";
 
 /** Unbounded owner selection; compose with FTS rowids or chunk mirror ownership
  * before ranking/LIMIT. EXISTS keeps multiple tags/scopes from duplicating owners.
@@ -14,6 +16,16 @@ export function buildEligibleDocumentQuery(
   // Build tag filter conditions using EXISTS subqueries
   const conditions: string[] = ["d.active = 1"];
   const params: (string | number)[] = [];
+  if (options.filter) {
+    const predicate = compileMetadataPredicate(options.filter);
+    conditions.push(
+      "d.ingest_version >= ?",
+      "d.metadata_error IS NULL",
+      "d.typed_metadata IS NOT NULL",
+      predicate.sql
+    );
+    params.push(TYPED_METADATA_INGEST_VERSION, ...predicate.params);
+  }
   if (options.chunkLanguage) {
     conditions.push(
       "EXISTS (SELECT 1 FROM content_chunks lc WHERE lc.mirror_hash = d.mirror_hash AND lc.language = ?)"

package/src/store/sqlite/metadata-predicate.ts

@@ -0,0 +1,71 @@
+import type {
+  MetadataPredicate,
+  MetadataScalar,
+} from "../../core/typed-metadata";
+
+import { normalizeMetadataPredicate } from "../../core/typed-metadata";
+
+/** JSON keys and values are bound parameters, never paths or SQL fragments. */
+export function compileMetadataPredicate(input: MetadataPredicate): {
+  sql: string;
+  params: (string | number)[];
+} {
+  const params: (string | number)[] = [];
+  const bind = (value: string | number): string => {
+    params.push(value);
+    return "?";
+  };
+  const scalar = (alias: string, value: MetadataScalar): string => {
+    const type =
+      typeof value === "number"
+        ? `${alias}.type IN ('integer','real')`
+        : typeof value === "boolean"
+          ? `${alias}.type IN ('true','false')`
+          : `${alias}.type = 'text'`;
+    return `(${type} AND ${alias}.value = ${bind(typeof value === "boolean" ? Number(value) : value)})`;
+  };
+  const compile = (node: MetadataPredicate): string => {
+    if (node.op === "and" || node.op === "or")
+      return `(${node.predicates.map(compile).join(node.op === "and" ? " AND " : " OR ")})`;
+    if (node.op === "not") return `NOT (${compile(node.predicate)})`;
+    if (!("key" in node)) throw new Error("Invalid metadata predicate");
+    const key = bind(node.key);
+    const select = `SELECT 1 FROM json_each(d.typed_metadata) mf WHERE mf.key = ${key}`;
+    if (node.op === "exists")
+      return `${node.value ? "" : "NOT "}EXISTS (${select})`;
+    if ("values" in node) {
+      if (node.op === "all") {
+        const conditions = node.values.map(
+          (value) =>
+            `EXISTS (SELECT 1 FROM json_each(mf.value) mv WHERE ${scalar("mv", value)})`
+        );
+        return `EXISTS (${select} AND CASE WHEN mf.type = 'array' THEN (${conditions.join(" AND ")}) ELSE 0 END)`;
+      }
+      const arrayMatches = node.values
+        .map((value) => scalar("mv", value))
+        .join(" OR ");
+      const scalarMatches = node.values
+        .map((value) => scalar("mf", value))
+        .join(" OR ");
+      const match = `CASE WHEN mf.type = 'array' THEN EXISTS (SELECT 1 FROM json_each(mf.value) mv WHERE ${arrayMatches}) ELSE (${scalarMatches}) END`;
+      return `EXISTS (${select} AND ${node.op === "nin" ? "NOT " : ""}(${match}))`;
+    }
+    if (node.op === "eq")
+      return `EXISTS (${select} AND ${scalar("mf", node.value)})`;
+    if (node.op === "ne") {
+      const equal = scalar("mf", node.value);
+      const type =
+        typeof node.value === "number"
+          ? "mf.type IN ('integer','real')"
+          : typeof node.value === "boolean"
+            ? "mf.type IN ('true','false')"
+            : "mf.type = 'text'";
+      return `EXISTS (${select} AND ${type} AND NOT ${equal})`;
+    }
+    if (typeof node.value !== "number")
+      throw new Error("Ordering requires a number");
+    const operators = { gt: ">", gte: ">=", lt: "<", lte: "<=" } as const;
+    return `EXISTS (${select} AND mf.type IN ('integer','real') AND mf.value ${operators[node.op]} ${bind(node.value)})`;
+  };
+  return { sql: compile(normalizeMetadataPredicate(input)), params };
+}

package/src/store/types.ts

@@ -20,6 +20,7 @@ import type {
   FileRefactorRecoveryReceipt,
   FileRefactorRecoveryReceiptDraft,
 } from "../core/file-refactor-journal";
+import type { MetadataPredicate, TypedMetadata } from "../core/typed-metadata";
 import type {
   ChunkingPolicyToken,
   ChunkingStatus,
@@ -119,6 +120,8 @@ export interface ContextRow {
 
 /** Document row from DB */
 export interface DocumentRow {
+  typedMetadata?: TypedMetadata | null;
+  metadataError?: string | null;
   id: number;
   collection: string;
   relPath: string;
@@ -377,6 +380,8 @@ export interface DocEdgeInput {
 
 /** Input for upserting a document */
 export interface DocumentInput {
+  typedMetadata?: TypedMetadata;
+  metadataError?: string;
   collection: string;
   relPath: string;
   sourceHash: string;
@@ -667,6 +672,7 @@ export interface GraphReferenceStore {
 }
 
 export interface DocumentEligibilityOptions {
+  filter?: MetadataPredicate;
   /** Internal owner eligibility; public lexical language remains reserved. */
   chunkLanguage?: string;
   /** Include author, content type and categories in whole-owner exclusion. */
@@ -793,6 +799,7 @@ export interface CollectionStatus {
 
 /** Index-level status */
 export interface IndexStatus {
+  typedMetadata?: { pending: number; invalid: number };
   /** Config version string */
   version: string;
   /** Index name (from dbPath) */
@@ -1522,6 +1529,9 @@ export type WithTransaction = <T>(
  * Implementations: SQLite adapter (src/store/sqlite/adapter.ts)
  */
 export interface StorePort {
+  getTypedMetadataCoverage?(
+    options: DocumentEligibilityOptions
+  ): Promise<StoreResult<{ pending: number; invalid: number }>>;
   // ─────────────────────────────────────────────────────────────────────────
   // Lifecycle
   // ─────────────────────────────────────────────────────────────────────────
@@ -1869,6 +1879,7 @@ export interface StorePort {
     options?: {
       collection?: string;
       activeOnly?: boolean;
+      eligibility?: DocumentEligibilityOptions;
     }
   ): Promise<StoreResult<DocumentRow[]>>;
 

package/browser-extension/artifacts/gno-browser-clipper-v2.3.2.zip.sha256

@@ -1 +0,0 @@
-293a8a52bc9368e6755cc9a23970f83fc6c0344a6832132c93a65b9c73bc3e28  gno-browser-clipper-v2.3.2.zip