exovault-mcp-server 1.4.0 → 1.5.0

package/dist/db.d.ts

@@ -62,6 +62,12 @@ export interface MemoryRow {
     source_note_ids: string[] | null;
     superseded_by_id: string | null;
     entities: string[] | null;
+    entity_descriptions: Array<{
+        name: string;
+        type: string;
+        description: string;
+    }> | null;
+    community_id: number | null;
     created_at: string;
     updated_at: string;
 }
@@ -97,6 +103,8 @@ export declare function getMemories(supabase: SupabaseClient, userId: string, op
     includeArchived?: boolean;
     limit?: number;
     orderBy?: "updated_at" | "importance";
+    /** Use lightweight columns (no encrypted content/summary). Default: false. */
+    lightweight?: boolean;
 }): Promise<MemoryRow[]>;
 export declare function getMemory(supabase: SupabaseClient, userId: string, memoryId: string): Promise<MemoryRow | null>;
 export declare function getMemoryByExternalWriteId(supabase: SupabaseClient, userId: string, externalWriteId: string): Promise<MemoryRow | null>;
@@ -123,6 +131,11 @@ export declare function insertMemory(supabase: SupabaseClient, data: {
     source_note_ids?: string[] | null;
     superseded_by_id?: string | null;
     entities?: string[] | null;
+    entity_descriptions?: Array<{
+        name: string;
+        type: string;
+        description: string;
+    }> | null;
     blind_tokens?: string[] | null;
     indexing_status?: string;
 }): Promise<MemoryRow>;
@@ -169,7 +182,7 @@ export interface MemoryEmbeddingMatch {
     importance: number;
 }
 export declare function matchNoteEmbeddings(supabase: SupabaseClient, embedding: number[], userId: string, threshold?: number, count?: number): Promise<EmbeddingMatch[]>;
-export declare function matchMemoryEmbeddings(supabase: SupabaseClient, embedding: number[], userId: string, threshold?: number, count?: number): Promise<MemoryEmbeddingMatch[]>;
+export declare function matchMemoryEmbeddings(supabase: SupabaseClient, embedding: number[], userId: string, threshold?: number, count?: number, vaultIds?: string[] | null): Promise<MemoryEmbeddingMatch[]>;
 export interface BlindTokenMatch {
     memory_id: string;
     match_count: number;
@@ -223,6 +236,16 @@ export interface MemoryHealthStats {
 }
 export declare function getMemoryHealthStats(supabase: SupabaseClient, userId: string, vaultId?: string): Promise<MemoryHealthStats>;
 export declare function searchMemoriesByEntity(supabase: SupabaseClient, userId: string, entity: string, limit?: number): Promise<MemoryRow[]>;
+/**
+ * Fetch memory IDs that belong to any of the given community clusters.
+ * Used by community routing signal in search.
+ */
+export declare function getMemoryIdsByCommunityIds(supabase: SupabaseClient, userId: string, communityIds: number[], limit?: number, vaultId?: string): Promise<string[]>;
+/**
+ * Fetch community_ids for a set of memory IDs. Used to resolve
+ * which communities the entity signal hits belong to.
+ */
+export declare function getCommunityIdsForMemories(supabase: SupabaseClient, userId: string, memoryIds: string[]): Promise<number[]>;
 export declare function getRelatedMemoriesById(supabase: SupabaseClient, userId: string, memoryId: string, limit?: number): Promise<{
     source: MemoryRow | null;
     related: MemoryRow[];
@@ -242,6 +265,7 @@ export interface KnowledgeLinkRow {
     relation_type: LinkRelationType;
     encrypted_label: string | null;
     label_iv: string | null;
+    confidence: number;
     is_pending: boolean;
     pending_target_hash: string | null;
     created_at: string;
@@ -256,6 +280,7 @@ export declare function insertKnowledgeLink(supabase: SupabaseClient, data: {
     relation_type: LinkRelationType;
     encrypted_label?: string | null;
     label_iv?: string | null;
+    confidence?: number;
     is_pending?: boolean;
     pending_target_hash?: string | null;
     created_by?: string | null;
@@ -276,10 +301,13 @@ export declare function bulkInsertKnowledgeLinks(supabase: SupabaseClient, links
     relation_type: LinkRelationType;
     encrypted_label?: string | null;
     label_iv?: string | null;
+    confidence?: number;
     is_pending?: boolean;
     pending_target_hash?: string | null;
     created_by?: string | null;
-}>): Promise<number>;
+}>): Promise<Array<{
+    id: string;
+}>>;
 /**
  * Resolves pending wiki-links by matching stored SHA-256 hashes against
  * candidate note names. Caller provides a map of hash → noteId.
@@ -295,6 +323,25 @@ export declare function getKnowledgeGraph(supabase: SupabaseClient, userId: stri
     from_id: string;
     relation: LinkRelationType;
 }>>;
+export declare function insertRelationshipEmbedding(supabase: SupabaseClient, data: {
+    user_id: string;
+    link_id: string;
+    source_entity: string;
+    target_entity: string;
+    keywords: string;
+    encrypted_description?: string | null;
+    description_iv?: string | null;
+    embedding_model: string;
+    embedding: number[];
+}): Promise<void>;
+export declare function matchRelationshipEmbeddings(supabase: SupabaseClient, queryEmbedding: number[], userId: string, threshold?: number, matchCount?: number): Promise<Array<{
+    id: string;
+    link_id: string;
+    source_entity: string;
+    target_entity: string;
+    keywords: string;
+    similarity: number;
+}>>;
 export interface AgentMessageRow {
     id: string;
     user_id: string;

package/dist/db.js

@@ -1,9 +1,14 @@
 import { sanitizeDbError } from "./error-sanitizer.js";
+// ─── Column lists (explicit to avoid SELECT * egress overhead) ───────────────
+const VAULT_COLUMNS = "id, user_id, encrypted_name, name_iv, icon, color, sort_order, created_at, updated_at";
+const NOTE_COLUMNS = "id, user_id, vault_id, encrypted_title, title_iv, encrypted_content, content_iv, content_type, encrypted_tags, tags_iv, embedding_status, import_source, import_source_id, is_trashed, created_at, updated_at";
+const LINK_COLUMNS = "id, user_id, source_type, source_id, target_type, target_id, relation_type, encrypted_label, label_iv, confidence, is_pending, pending_target_hash, created_at, created_by";
+const MESSAGE_COLUMNS = "id, user_id, vault_id, sender_type, sender_id, target_type, target_id, category, priority, subject, encrypted_content, content_iv, status, delivered_at, acknowledged_at, parent_message_id, thread_id, expires_at, metadata, created_at, updated_at";
 // ─── Query helpers ────────────────────────────────────────────────────────────
 export async function getVaults(supabase, userId) {
     const { data, error } = await supabase
         .from("vaults")
-        .select("*")
+        .select(VAULT_COLUMNS)
         .eq("user_id", userId)
         .order("sort_order", { ascending: true });
     if (error)
@@ -13,7 +18,7 @@ export async function getVaults(supabase, userId) {
 export async function getNotes(supabase, userId, vaultId, limit = 20) {
     let query = supabase
         .from("notes")
-        .select("*")
+        .select(NOTE_COLUMNS)
         .eq("user_id", userId)
         .eq("is_trashed", false)
         .order("updated_at", { ascending: false })
@@ -29,7 +34,7 @@ export async function getNotes(supabase, userId, vaultId, limit = 20) {
 export async function getNote(supabase, userId, noteId) {
     const { data, error } = await supabase
         .from("notes")
-        .select("*")
+        .select(NOTE_COLUMNS)
         .eq("id", noteId)
         .eq("user_id", userId)
         .single();
@@ -43,7 +48,7 @@ export async function getNote(supabase, userId, noteId) {
 export async function getVault(supabase, userId, vaultId) {
     const { data, error } = await supabase
         .from("vaults")
-        .select("*")
+        .select(VAULT_COLUMNS)
         .eq("id", vaultId)
         .eq("user_id", userId)
         .single();
@@ -102,9 +107,15 @@ export async function getMemories(supabase, userId, options) {
     const includeArchived = options?.includeArchived ?? false;
     const limit = options?.limit ?? 50;
     const orderBy = options?.orderBy ?? "updated_at";
+    // Lightweight mode: select only metadata columns (no encrypted content/summary) to reduce egress.
+    // Supabase's TS type parser can't handle long literal strings, so we build the query separately.
+    const columns = options?.lightweight
+        ? "id,user_id,vault_id,memory_type,agent_id,agent_type,model_id,agent_run_id,importance,confidence,access_count,is_archived,entities,superseded_by_id,created_at,updated_at"
+        : "*";
     let query = supabase
         .from("memories")
-        .select("*")
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        .select(columns)
         .eq("user_id", userId)
         .order(orderBy, { ascending: false })
         .limit(limit);
@@ -277,21 +288,23 @@ export async function getEmbeddingsForMemories(supabase, userId, memoryIds) {
 }
 export async function matchNoteEmbeddings(supabase, embedding, userId, threshold = 0.5, count = 20) {
     const { data, error } = await supabase.rpc("match_note_embeddings", {
-        query_embedding: JSON.stringify(embedding),
-        match_threshold: threshold,
-        match_count: count,
+        p_embedding: JSON.stringify(embedding),
+        p_match_threshold: threshold,
+        p_match_count: count,
         p_user_id: userId,
+        p_vault_ids: null,
     });
     if (error)
         throw new Error(sanitizeDbError("match note embeddings", error.message));
     return (data ?? []);
 }
-export async function matchMemoryEmbeddings(supabase, embedding, userId, threshold = 0.5, count = 20) {
+export async function matchMemoryEmbeddings(supabase, embedding, userId, threshold = 0.5, count = 20, vaultIds) {
     const { data, error } = await supabase.rpc("match_memory_embeddings", {
-        query_embedding: JSON.stringify(embedding),
-        match_threshold: threshold,
-        match_count: count,
+        p_embedding: JSON.stringify(embedding),
+        p_match_threshold: threshold,
+        p_match_count: count,
         p_user_id: userId,
+        p_vault_ids: vaultIds ?? null,
     });
     if (error)
         throw new Error(sanitizeDbError("match memory embeddings", error.message));
@@ -310,6 +323,7 @@ export async function matchMemoriesByBlindTokens(supabase, tokenHashes, userId,
         p_vault_id: vaultId ?? null,
         p_match_count: count,
         p_include_archived: includeArchived,
+        p_vault_ids: null,
     });
     if (error)
         throw new Error(sanitizeDbError("match memories by blind tokens", error.message));
@@ -328,6 +342,7 @@ export async function matchNotesByBlindTokens(supabase, tokenHashes, userId, vau
         p_vault_id: vaultId ?? null,
         p_match_count: count,
         p_include_trashed: includeTrashed,
+        p_vault_ids: null,
     });
     if (error)
         throw new Error(sanitizeDbError("match notes by blind tokens", error.message));
@@ -339,7 +354,7 @@ export async function getNotesByIds(supabase, userId, noteIds) {
         return [];
     const { data, error } = await supabase
         .from("notes")
-        .select("*")
+        .select(NOTE_COLUMNS)
         .eq("user_id", userId)
         .eq("is_trashed", false)
         .in("id", noteIds);
@@ -350,7 +365,7 @@ export async function getNotesByIds(supabase, userId, noteIds) {
 export async function getNoteByImportSource(supabase, userId, vaultId, importSource, importSourceId) {
     const { data, error } = await supabase
         .from("notes")
-        .select("*")
+        .select(NOTE_COLUMNS)
         .eq("user_id", userId)
         .eq("vault_id", vaultId)
         .eq("import_source", importSource)
@@ -492,6 +507,46 @@ export async function searchMemoriesByEntity(supabase, userId, entity, limit = 2
         throw new Error(sanitizeDbError("search memories by entity", error.message));
     return (data ?? []);
 }
+/**
+ * Fetch memory IDs that belong to any of the given community clusters.
+ * Used by community routing signal in search.
+ */
+export async function getMemoryIdsByCommunityIds(supabase, userId, communityIds, limit = 30, vaultId) {
+    if (communityIds.length === 0)
+        return [];
+    let query = supabase
+        .from("memories")
+        .select("id")
+        .eq("user_id", userId)
+        .eq("is_archived", false)
+        .in("community_id", communityIds);
+    if (vaultId) {
+        query = query.eq("vault_id", vaultId);
+    }
+    const { data, error } = await query
+        .order("updated_at", { ascending: false })
+        .limit(limit);
+    if (error)
+        throw new Error(sanitizeDbError("community routing", error.message));
+    return (data ?? []).map((r) => r.id);
+}
+/**
+ * Fetch community_ids for a set of memory IDs. Used to resolve
+ * which communities the entity signal hits belong to.
+ */
+export async function getCommunityIdsForMemories(supabase, userId, memoryIds) {
+    if (memoryIds.length === 0)
+        return [];
+    const { data, error } = await supabase
+        .from("memories")
+        .select("community_id")
+        .eq("user_id", userId)
+        .in("id", memoryIds.slice(0, 50))
+        .not("community_id", "is", null);
+    if (error)
+        throw new Error(sanitizeDbError("community id lookup", error.message));
+    return [...new Set((data ?? []).map((r) => r.community_id))];
+}
 export async function getRelatedMemoriesById(supabase, userId, memoryId, limit = 20) {
     // Fetch the source memory
     const source = await getMemory(supabase, userId, memoryId);
@@ -580,10 +635,11 @@ export async function insertKnowledgeLink(supabase, data) {
         encrypted_label: data.encrypted_label ?? null,
         label_iv: data.label_iv ?? null,
         is_pending: data.is_pending ?? false,
+        confidence: data.confidence ?? 0.8,
         pending_target_hash: data.pending_target_hash ?? null,
         created_by: data.created_by ?? null,
     })
-        .select()
+        .select(LINK_COLUMNS)
         .single();
     if (error)
         throw new Error(sanitizeDbError("insert knowledge link", error.message));
@@ -604,7 +660,7 @@ export async function getLinksForNode(supabase, userId, nodeType, nodeId, option
     if (direction === "outgoing") {
         const { data, error } = await supabase
             .from("knowledge_links")
-            .select()
+            .select(LINK_COLUMNS)
             .eq("user_id", userId)
             .eq("source_type", nodeType)
             .eq("source_id", nodeId)
@@ -617,7 +673,7 @@ export async function getLinksForNode(supabase, userId, nodeType, nodeId, option
     if (direction === "incoming") {
         const { data, error } = await supabase
             .from("knowledge_links")
-            .select()
+            .select(LINK_COLUMNS)
             .eq("user_id", userId)
             .eq("target_type", nodeType)
             .eq("target_id", nodeId)
@@ -631,7 +687,7 @@ export async function getLinksForNode(supabase, userId, nodeType, nodeId, option
     const [outgoing, incoming] = await Promise.all([
         supabase
             .from("knowledge_links")
-            .select()
+            .select(LINK_COLUMNS)
             .eq("user_id", userId)
             .eq("source_type", nodeType)
             .eq("source_id", nodeId)
@@ -639,7 +695,7 @@ export async function getLinksForNode(supabase, userId, nodeType, nodeId, option
             .limit(limit),
         supabase
             .from("knowledge_links")
-            .select()
+            .select(LINK_COLUMNS)
             .eq("user_id", userId)
             .eq("target_type", nodeType)
             .eq("target_id", nodeId)
@@ -690,7 +746,7 @@ export async function deleteLinksForNode(supabase, userId, nodeType, nodeId) {
 }
 export async function bulkInsertKnowledgeLinks(supabase, links) {
     if (links.length === 0)
-        return 0;
+        return [];
     const rows = links.map((l) => ({
         user_id: l.user_id,
         source_type: l.source_type,
@@ -700,6 +756,7 @@ export async function bulkInsertKnowledgeLinks(supabase, links) {
         relation_type: l.relation_type,
         encrypted_label: l.encrypted_label ?? null,
         label_iv: l.label_iv ?? null,
+        confidence: l.confidence ?? 0.8,
         is_pending: l.is_pending ?? false,
         pending_target_hash: l.pending_target_hash ?? null,
         created_by: l.created_by ?? null,
@@ -711,7 +768,7 @@ export async function bulkInsertKnowledgeLinks(supabase, links) {
         .select("id");
     if (error)
         throw new Error(sanitizeDbError("bulk insert knowledge links", error.message));
-    return data?.length ?? 0;
+    return (data ?? []);
 }
 /**
  * Resolves pending wiki-links by matching stored SHA-256 hashes against
@@ -724,7 +781,7 @@ export async function resolvePendingLinks(supabase, userId, hashToNoteId) {
     // Fetch all pending links for this user
     const { data: pending, error } = await supabase
         .from("knowledge_links")
-        .select()
+        .select(LINK_COLUMNS)
         .eq("user_id", userId)
         .eq("is_pending", true)
         .limit(10_000);
@@ -766,6 +823,25 @@ export async function getKnowledgeGraph(supabase, userId, nodeType, nodeId, maxH
         throw new Error(sanitizeDbError("traverse knowledge graph", error.message));
     return (data ?? []);
 }
+// ─── Relationship Embeddings ─────────────────────────────────────────────────
+export async function insertRelationshipEmbedding(supabase, data) {
+    const { error } = await supabase
+        .from("relationship_embeddings")
+        .upsert(data, { onConflict: "user_id,link_id,embedding_model" });
+    if (error)
+        throw new Error(sanitizeDbError("upsert relationship embedding", error.message));
+}
+export async function matchRelationshipEmbeddings(supabase, queryEmbedding, userId, threshold = 0.4, matchCount = 10) {
+    const { data, error } = await supabase.rpc("match_relationship_embeddings", {
+        p_user_id: userId,
+        p_query_embedding: JSON.stringify(queryEmbedding),
+        p_match_threshold: threshold,
+        p_match_count: matchCount,
+    });
+    if (error)
+        throw new Error(sanitizeDbError("match relationship embeddings", error.message));
+    return data ?? [];
+}
 export async function insertAgentMessage(supabase, data) {
     const { data: row, error } = await supabase
         .from("agent_messages")
@@ -786,7 +862,7 @@ export async function insertAgentMessage(supabase, data) {
         parent_message_id: data.parent_message_id ?? null,
         thread_id: data.thread_id ?? null,
     })
-        .select("*")
+        .select(MESSAGE_COLUMNS)
         .single();
     if (error)
         throw new Error(sanitizeDbError("insert agent message", error.message));
@@ -799,7 +875,7 @@ export async function insertAgentMessage(supabase, data) {
 export async function getPendingMessages(supabase, userId, targetId, limit = 5) {
     const { data, error } = await supabase
         .from("agent_messages")
-        .select("*")
+        .select(MESSAGE_COLUMNS)
         .eq("user_id", userId)
         .eq("status", "pending")
         .or(`target_id.eq.${targetId},target_id.eq.*`)
@@ -819,7 +895,7 @@ export async function getAgentMessages(supabase, userId, targetId, options) {
     const includeBroadcast = options?.includeBroadcast ?? true;
     let query = supabase
         .from("agent_messages")
-        .select("*")
+        .select(MESSAGE_COLUMNS)
         .eq("user_id", userId)
         .order("priority", { ascending: false })
         .order("created_at", { ascending: false })
@@ -890,7 +966,7 @@ export async function resolveThreadId(supabase, userId, parentMessageId) {
 export async function getThread(supabase, userId, threadId) {
     const { data, error } = await supabase
         .from("agent_messages")
-        .select("*")
+        .select(MESSAGE_COLUMNS)
         .eq("user_id", userId)
         .eq("thread_id", threadId)
         .order("created_at", { ascending: true });

package/dist/default-documents.d.ts

@@ -0,0 +1,22 @@
+/**
+ * System default documents for direct/stdio mode.
+ *
+ * In gateway mode, the HTTP API loads user-customized documents from the database.
+ * In direct mode, we serve these system defaults since we don't have access to
+ * the vault settings infrastructure. Users who customize documents should use
+ * gateway mode (recommended).
+ *
+ * NOTE: Keep in sync with src/lib/settings/default-documents.ts in the main app.
+ */
+export declare const DOCUMENT_TYPES: readonly ["soul", "instructions", "skills", "checks"];
+export type DocumentType = (typeof DOCUMENT_TYPES)[number];
+export interface DefaultDocumentTemplate {
+    content: string;
+    version: number;
+    inheritMode: "replace" | "append" | "none";
+    agentEditable: boolean;
+    appendOnly: boolean;
+}
+export declare const CURRENT_TEMPLATE_VERSION = 5;
+/** Get default plaintext for a specific document type */
+export declare function getDefaultDocumentContent(type: DocumentType): DefaultDocumentTemplate;