@x12i/catalox 3.4.0 → 3.4.5

package/dist/src/catalox/catalox.js

@@ -28,6 +28,8 @@ import { SnapshotStore } from "../firebase/snapshot-store.js";
 import { StoreAppBindingStore } from "../firebase/store-app-binding-store.js";
 import { IdentityBindingStore } from "../firebase/identity-binding-store.js";
 import { nativeItemsCollectionId } from "../firebase/catalog-data-paths.js";
+import { applyCatalogVisibilityFilter, filterCatalogsByText, findCatalogsByAi as findCatalogsByAiHelper, summarizeCatalog, } from "./catalog-discovery.js";
+import { loadAiFunctions } from "./ai-functions-loader.js";
 import { runBackupData, pruneGcsBackupRuns } from "./backup-data.js";
 import { runUndoFirestoreRestore } from "./restore-firestore-backup.js";
 import { runRestoreFirestoreBackupFromGcs, runDeleteCataloxGcsBackupRun } from "./restore-firestore-backup-from-gcs.js";
@@ -517,6 +519,33 @@ export class Catalox {
         }
         return out.filter((e) => (input.includeHidden ? true : e.visibility !== "hidden"));
     }
+    /**
+     * App-agnostic discovery: list catalog metadata across all apps.
+     * Visibility default: hide hidden catalogs unless `context.superAdmin`.
+     */
+    async listAllCatalogs(context, input) {
+        const catalogs = await this.deps.catalogs.listAll();
+        const out = [];
+        for (const c of catalogs) {
+            const d = await this.deps.descriptors.get(c.catalogId);
+            out.push(summarizeCatalog(c, d));
+        }
+        return applyCatalogVisibilityFilter(out, context, input);
+    }
+    async findCatalogs(context, input) {
+        const all = await this.listAllCatalogs(context, {
+            ...(input.includeDisabled != null ? { includeDisabled: input.includeDisabled } : {}),
+            ...(input.includeHidden != null ? { includeHidden: input.includeHidden } : {}),
+        });
+        return filterCatalogsByText(all, input);
+    }
+    async findCatalogsByAi(context, input) {
+        const all = await this.listAllCatalogs(context, {
+            ...(input.includeDisabled != null ? { includeDisabled: input.includeDisabled } : {}),
+            ...(input.includeHidden != null ? { includeHidden: input.includeHidden } : {}),
+        });
+        return findCatalogsByAiHelper({ query: input.query, catalogs: all, input });
+    }
     async getCatalogDescriptor(context, catalogId) {
         await this.deps.authz.requireBindingAccess(context, context.appId, catalogId, "read");
         const rec = await this.deps.descriptors.get(catalogId);
@@ -891,6 +920,197 @@ export class Catalox {
     async listCatalogs(_context, _options) {
         return this.deps.catalogs.listAll();
     }
+    async searchCatalogItems(context, catalogId, input) {
+        const poolLimit = input.poolLimit ?? 200;
+        const limit = input.limit ?? 50;
+        const base = await this.listCatalogItems(context, catalogId, {
+            limit: poolLimit,
+            ...(input.scope ? { scope: input.scope } : {}),
+            ...(input.filter ? { filter: input.filter } : {}),
+            ...(input.sort ? { sort: input.sort } : {}),
+        });
+        if (base.listOutcome !== "ok")
+            return base;
+        const q = String(input.text ?? "").toLowerCase().trim();
+        if (!q)
+            return { ...base, items: [] };
+        const textFields = input.textFields ?? [];
+        const filtered = base.items.filter((it) => {
+            const parts = [];
+            if (it.title)
+                parts.push(String(it.title));
+            if (it.subtitle)
+                parts.push(String(it.subtitle));
+            const data = it.data;
+            for (const p of textFields) {
+                const v = this.readPath(data, p);
+                if (v == null)
+                    continue;
+                parts.push(typeof v === "string" || typeof v === "number" ? String(v) : JSON.stringify(v));
+            }
+            return parts.join(" ").toLowerCase().includes(q);
+        });
+        return { ...base, items: filtered.slice(0, limit) };
+    }
+    async findCatalogItemsByAi(context, catalogId, input) {
+        const poolLimit = input.poolLimit ?? 300;
+        const base = await this.listCatalogItems(context, catalogId, {
+            limit: poolLimit,
+            ...(input.scope ? { scope: input.scope } : {}),
+            ...(input.filter ? { filter: input.filter } : {}),
+            ...(input.sort ? { sort: input.sort } : {}),
+        });
+        if (base.listOutcome !== "ok")
+            return { query: input.query, hits: [], noMatch: true };
+        const items = base.items;
+        const candidates = items.map((it) => {
+            const title = it.title ? String(it.title) : "";
+            const subtitle = it.subtitle ? String(it.subtitle) : "";
+            const label = [title, subtitle].filter(Boolean).join(" — ") || String(it.itemId);
+            return {
+                id: String(it.itemId),
+                label,
+                metadata: { catalogId: String(catalogId) },
+            };
+        });
+        const { match } = await loadAiFunctions();
+        const res = await match({
+            query: input.query,
+            candidates,
+            ...(input.guidance ? { guidance: input.guidance } : {}),
+            ...(input.maxResults != null ? { maxResults: input.maxResults } : {}),
+            ...(input.minScore != null ? { minScore: input.minScore } : {}),
+            ...(input.allowNoMatch != null ? { allowNoMatch: input.allowNoMatch } : {}),
+            ...(input.returnReasons != null ? { returnReasons: input.returnReasons } : {}),
+            ...(input.additionalInstructions ? { additionalInstructions: input.additionalInstructions } : {}),
+            ...(input.maxCandidates != null ? { maxCandidates: input.maxCandidates } : {}),
+            ...(input.mode ? { mode: input.mode } : {}),
+            ...(input.client ? { client: input.client } : {}),
+            ...(input.model ? { model: input.model } : {}),
+            ...(input.temperature != null ? { temperature: input.temperature } : {}),
+            ...(input.maxTokens != null ? { maxTokens: input.maxTokens } : {}),
+            ...(input.timeoutMs != null ? { timeoutMs: input.timeoutMs } : {}),
+            ...(input.vendor != null ? { vendor: input.vendor } : {}),
+        });
+        const byId = new Map(items.map((it) => [String(it.itemId), it]));
+        const hits = res.matches
+            .map((m) => {
+            const it = byId.get(String(m.id));
+            if (!it)
+                return null;
+            return { itemId: it.itemId, score: m.score, ...(m.reason ? { reason: m.reason } : {}), item: it };
+        })
+            .filter(Boolean);
+        return { query: input.query, hits, noMatch: Boolean(res.noMatch) };
+    }
+    async createCatalogItemByAi(context, catalogId, input) {
+        await this.deps.authz.requireBindingAccess(context, context.appId, catalogId, "write");
+        const descRec = await this.deps.descriptors.get(catalogId);
+        if (!descRec)
+            throw new CatalogAdapterError({ catalogId, reason: "missing_descriptor" });
+        const rules = descRec.descriptor.creationRules;
+        if (!rules)
+            throw new CatalogAdapterError({ catalogId, reason: "creation_rules_missing" });
+        if (rules.enabled === false)
+            throw new CatalogAdapterError({ catalogId, reason: "creation_rules_disabled" });
+        const catalog = await this.deps.catalogs.get(catalogId);
+        if (!catalog)
+            throw new CatalogNotFoundError({ catalogId });
+        const existingLimit = input.existingItemsSampleLimit ?? 0;
+        const existingItemsSample = existingLimit > 0
+            ? (await this.listCatalogItems(context, catalogId, { limit: existingLimit })).items.map((i) => i.data)
+            : undefined;
+        const { createItem } = await loadAiFunctions();
+        const result = await createItem({
+            ...(descRec.descriptor.itemLabel ? { itemLabel: descRec.descriptor.itemLabel } : {}),
+            creationRules: rules,
+            provided: input.provided,
+            fieldSchema: (descRec.descriptor.queryableFields ?? []),
+            ...(existingItemsSample ? { existingItemsSample } : {}),
+            ...(input.additionalInstructions ? { additionalInstructions: input.additionalInstructions } : {}),
+            ...(input.mode ? { mode: input.mode } : {}),
+            ...(input.model ? { model: input.model } : {}),
+            ...(input.client ? { client: input.client } : {}),
+            ...(input.temperature != null ? { temperature: input.temperature } : {}),
+            ...(input.maxTokens != null ? { maxTokens: input.maxTokens } : {}),
+            ...(input.timeoutMs != null ? { timeoutMs: input.timeoutMs } : {}),
+            ...(input.vendor != null ? { vendor: input.vendor } : {}),
+        }, undefined);
+        const out = {
+            catalogId,
+            proposed: result.item ?? {},
+            issues: (result.issues ?? []),
+            ...(result.missingInputs ? { missingInputs: result.missingInputs } : {}),
+            noCreate: Boolean(result.noCreate),
+            ...(result.reason ? { reason: result.reason } : {}),
+        };
+        const autoPersist = input.autoPersist === true;
+        const hasErrors = (result.issues ?? []).some((i) => i?.severity === "error");
+        if (autoPersist && !out.noCreate && !hasErrors) {
+            if (catalog.sourceMode !== "native") {
+                throw new CatalogAdapterError({ catalogId, reason: "autopersist_mapped_unsupported" });
+            }
+            const writePayload = input.scope != null ? { ...out.proposed, scope: input.scope } : out.proposed;
+            out.item = await this.upsertNativeCatalogItem(context, catalogId, writePayload);
+        }
+        return out;
+    }
+    async modifyCatalogItemByAi(context, catalogId, itemId, input) {
+        await this.deps.authz.requireBindingAccess(context, context.appId, catalogId, "write");
+        const descRec = await this.deps.descriptors.get(catalogId);
+        if (!descRec)
+            throw new CatalogAdapterError({ catalogId, reason: "missing_descriptor" });
+        const rules = descRec.descriptor.modificationRules;
+        if (!rules)
+            throw new CatalogAdapterError({ catalogId, reason: "modification_rules_missing" });
+        if (rules.enabled === false)
+            throw new CatalogAdapterError({ catalogId, reason: "modification_rules_disabled" });
+        const catalog = await this.deps.catalogs.get(catalogId);
+        if (!catalog)
+            throw new CatalogNotFoundError({ catalogId });
+        const got = await this.getCatalogItem(context, catalogId, itemId, input.nativeItemOptions);
+        if (got.outcome === "mapping_blocked") {
+            throw new CatalogAdapterError({ catalogId, reason: "mapping_validation_failed", issues: got.issues });
+        }
+        if (got.outcome === "not_found")
+            throw new CatalogNotFoundError({ catalogId, itemId });
+        const currentItem = (got.item.data ?? {});
+        const { modifyItem } = await loadAiFunctions();
+        const result = await modifyItem({
+            ...(descRec.descriptor.itemLabel ? { itemLabel: descRec.descriptor.itemLabel } : {}),
+            currentItem: currentItem,
+            modificationRules: rules,
+            patch: input.patch,
+            fieldSchema: (descRec.descriptor.queryableFields ?? []),
+            ...(input.additionalInstructions ? { additionalInstructions: input.additionalInstructions } : {}),
+            ...(input.mode ? { mode: input.mode } : {}),
+            ...(input.model ? { model: input.model } : {}),
+            ...(input.client ? { client: input.client } : {}),
+            ...(input.temperature != null ? { temperature: input.temperature } : {}),
+            ...(input.maxTokens != null ? { maxTokens: input.maxTokens } : {}),
+            ...(input.timeoutMs != null ? { timeoutMs: input.timeoutMs } : {}),
+            ...(input.vendor != null ? { vendor: input.vendor } : {}),
+        }, undefined);
+        const out = {
+            catalogId,
+            itemId,
+            proposed: result.item ?? {},
+            diff: (result.diff ?? []),
+            issues: (result.issues ?? []),
+            ...(result.violatedRules ? { violatedRules: result.violatedRules } : {}),
+            noChange: Boolean(result.noChange),
+            ...(result.reason ? { reason: result.reason } : {}),
+        };
+        const autoPersist = input.autoPersist === true;
+        const hasErrors = (result.issues ?? []).some((i) => i?.severity === "error");
+        if (autoPersist && !out.noChange && !hasErrors) {
+            if (catalog.sourceMode !== "native") {
+                throw new CatalogAdapterError({ catalogId, reason: "autopersist_mapped_unsupported" });
+            }
+            out.item = await this.updateNativeCatalogItem(context, catalogId, itemId, out.proposed, input.nativeItemOptions);
+        }
+        return out;
+    }
     async bindCatalogToApp(_context, _input) {
         const existing = await this.deps.bindings.findByAppCatalog(_input.appId, _input.catalogId);
         if (existing)