@hubblecommerce/overmind-core 0.1.0

package/dist/src/processors/confluence-document.processor.js

@@ -0,0 +1,162 @@
+import { parseConfluenceHtml } from './confluence-html-parser.js';
+/**
+ * Split markdown content by H2 headings (## Section)
+ * Each H2 section becomes one chunk
+ */
+export function splitMarkdownBySections(markdown) {
+    const chunks = [];
+    // Split by H2 headings (## )
+    const h2Pattern = /^## (.+)$/gm;
+    const matches = [...markdown.matchAll(h2Pattern)];
+    if (matches.length === 0) {
+        // No H2 headings - treat entire content as single chunk
+        return [{
+                sectionTitle: undefined,
+                content: markdown.trim(),
+                sectionIndex: 0,
+            }];
+    }
+    // Process each section
+    for (let i = 0; i < matches.length; i++) {
+        const match = matches[i];
+        const sectionTitle = match[1].trim();
+        const startIndex = match.index ?? 0;
+        const endIndex = i < matches.length - 1 ? (matches[i + 1].index ?? markdown.length) : markdown.length;
+        const sectionContent = markdown.substring(startIndex, endIndex).trim();
+        chunks.push({
+            sectionTitle,
+            content: sectionContent,
+            sectionIndex: i,
+        });
+    }
+    return chunks;
+}
+/**
+ * Extract metadata from content
+ */
+function analyzeContent(content) {
+    const wordCount = content.split(/\s+/).filter(word => word.length > 0).length;
+    const hasCodeBlocks = /```/.test(content);
+    const hasTables = /\|.*\|/.test(content);
+    const hasLinks = /\[.+\]\(.+\)/.test(content);
+    return {
+        word_count: wordCount,
+        has_code_blocks: hasCodeBlocks,
+        has_tables: hasTables,
+        has_links: hasLinks,
+    };
+}
+/**
+ * Extract metadata from labels
+ * Categorizes labels into specific fields and collects the rest as keywords
+ */
+function extractMetadataFromLabels(labels) {
+    const contentTypeLabels = ['project-info', 'faq', 'guide', 'decision', 'template'];
+    const categoryLabels = ['active', 'maintenance', 'legacy', 'archived'];
+    const contentType = labels.find(label => contentTypeLabels.includes(label));
+    const customer = labels.find(label => label.startsWith('customer-'));
+    const category = labels.find(label => categoryLabels.includes(label));
+    // Keywords: all labels that weren't categorized
+    const categorizedLabels = new Set([
+        contentType,
+        customer,
+        category,
+    ].filter(Boolean));
+    const keywords = labels.filter(label => !categorizedLabels.has(label));
+    return {
+        content_type: contentType,
+        customer,
+        category,
+        keywords,
+    };
+}
+/**
+ * Process a Confluence page into section-based chunks
+ * One chunk per H2 section
+ */
+export function processConfluencePage(page, spaceKey, baseUrl, labels = []) {
+    // Extract HTML content
+    const htmlContent = page.body?.storage?.value;
+    if (!htmlContent) {
+        console.warn(`Page ${page.id} (${page.title}) has no content, skipping`);
+        return [];
+    }
+    // Parse HTML to Markdown
+    const markdown = parseConfluenceHtml(htmlContent);
+    if (!markdown || markdown.trim().length === 0) {
+        console.warn(`Page ${page.id} (${page.title}) resulted in empty markdown after parsing, skipping`);
+        return [];
+    }
+    // Split by H2 sections
+    const sections = splitMarkdownBySections(markdown);
+    // Construct page URL
+    const pageUrl = `${baseUrl.replace(/\/$/, '')}/wiki${page._links.webui}`;
+    // Generate document ID base
+    const documentIdBase = `confluence:${spaceKey}:${page.id}`;
+    // Extract metadata from labels
+    const labelMetadata = extractMetadataFromLabels(labels);
+    // Get current timestamp
+    const indexedAt = new Date().toISOString();
+    // Create chunks
+    const chunks = sections.map((section) => {
+        // Analyze content
+        const contentAnalysis = analyzeContent(section.content);
+        // Determine chunk type
+        const chunkType = section.sectionTitle ? 'section' : 'full_page';
+        // Create document ID
+        const documentId = `${documentIdBase}_section_${section.sectionIndex}`;
+        const metadata = {
+            // === Source Info ===
+            source: 'confluence',
+            page_id: page.id,
+            page_title: page.title,
+            page_url: pageUrl,
+            space_key: spaceKey,
+            // === Content Structure ===
+            section_title: section.sectionTitle,
+            section_index: section.sectionIndex,
+            chunk_type: chunkType,
+            // === Labels ===
+            labels,
+            // === Extracted Metadata ===
+            ...labelMetadata,
+            // === Timestamps ===
+            last_updated: page.version.createdAt,
+            page_version: page.version.number,
+            indexed_at: indexedAt,
+            // === Author Info ===
+            last_updated_by: page.version.authorId,
+            page_creator: page.authorId,
+            // === Quality Indicators ===
+            ...contentAnalysis,
+            // === Parent Context ===
+            parent_page_id: page.parentId,
+            // === Standard fields ===
+            document_id: documentId,
+            document_type: 'confluence_page',
+        };
+        return {
+            pageContent: section.content,
+            metadata,
+        };
+    });
+    return chunks;
+}
+/**
+ * Process multiple Confluence pages in batch
+ */
+export function processConfluencePages(pages, spaceKey, baseUrl, labelsMap = new Map()) {
+    const allChunks = [];
+    for (const page of pages) {
+        try {
+            const labels = labelsMap.get(page.id) || [];
+            const pageChunks = processConfluencePage(page, spaceKey, baseUrl, labels);
+            allChunks.push(...pageChunks);
+        }
+        catch (error) {
+            console.error(`Error processing page ${page.id} (${page.title}):`, error);
+            // Continue with other pages
+        }
+    }
+    return allChunks;
+}

package/dist/src/processors/confluence-html-parser.js

@@ -0,0 +1,220 @@
+import TurndownService from 'turndown';
+/**
+ * Parse Confluence storage format HTML to clean Markdown
+ * Uses Turndown with custom rules for Confluence-specific elements
+ */
+export function parseConfluenceHtml(html) {
+    const turndownService = new TurndownService({
+        headingStyle: 'atx', // Use # for headings
+        hr: '---',
+        bulletListMarker: '-',
+        codeBlockStyle: 'fenced',
+        emDelimiter: '*',
+        strongDelimiter: '**',
+    });
+    // Add custom rules for Confluence-specific elements
+    addConfluenceRules(turndownService);
+    // Convert HTML to Markdown
+    const markdown = turndownService.turndown(html);
+    // Clean up extra whitespace
+    return markdown
+        .replace(/\n{3,}/g, '\n\n') // Max 2 consecutive newlines
+        .replace(/[ \t]+$/gm, '') // Remove trailing spaces
+        .trim();
+}
+/**
+ * Add custom Turndown rules for Confluence storage format elements
+ */
+function addConfluenceRules(turndownService) {
+    // Confluence Code Macro
+    turndownService.addRule('confluenceCodeMacro', {
+        filter: function (node) {
+            return (node.nodeName === 'AC:STRUCTURED-MACRO' &&
+                node.getAttribute('ac:name') === 'code');
+        },
+        replacement: function (content, node) {
+            // Extract language parameter
+            const langParam = node.querySelector('ac\\:parameter[ac\\:name="language"]');
+            const language = langParam?.textContent || '';
+            // Extract code content
+            const codeBody = node.querySelector('ac\\:plain-text-body');
+            const code = codeBody?.textContent || '';
+            return '\n```' + language + '\n' + code + '\n```\n';
+        },
+    });
+    // Confluence Info/Warning/Note/Tip Panels
+    turndownService.addRule('confluenceInfoPanels', {
+        filter: function (node) {
+            if (node.nodeName !== 'AC:STRUCTURED-MACRO')
+                return false;
+            const macroName = node.getAttribute('ac:name');
+            return ['info', 'note', 'tip', 'warning', 'panel'].includes(macroName || '');
+        },
+        replacement: function (content, node) {
+            const element = node;
+            const macroName = element.getAttribute('ac:name') || 'info';
+            // Extract content from rich-text-body or plain-text-body
+            const richTextBody = element.querySelector('ac\\:rich-text-body');
+            const plainTextBody = element.querySelector('ac\\:plain-text-body');
+            const bodyContent = richTextBody?.textContent || plainTextBody?.textContent || content;
+            // Format as blockquote with label
+            const label = macroName.toUpperCase();
+            return '\n> **' + label + '**: ' + bodyContent.trim() + '\n\n';
+        },
+    });
+    // Confluence TOC (Table of Contents) Macro
+    turndownService.addRule('confluenceTocMacro', {
+        filter: function (node) {
+            return (node.nodeName === 'AC:STRUCTURED-MACRO' &&
+                node.getAttribute('ac:name') === 'toc');
+        },
+        replacement: function () {
+            return '\n**Table of Contents**\n\n';
+        },
+    });
+    // Confluence Excerpt Macro
+    turndownService.addRule('confluenceExcerptMacro', {
+        filter: function (node) {
+            return (node.nodeName === 'AC:STRUCTURED-MACRO' &&
+                node.getAttribute('ac:name') === 'excerpt');
+        },
+        replacement: function (content, node) {
+            const richTextBody = node.querySelector('ac\\:rich-text-body');
+            return richTextBody?.textContent || content;
+        },
+    });
+    // Confluence Expand Macro (collapsible sections)
+    turndownService.addRule('confluenceExpandMacro', {
+        filter: function (node) {
+            return (node.nodeName === 'AC:STRUCTURED-MACRO' &&
+                node.getAttribute('ac:name') === 'expand');
+        },
+        replacement: function (content, node) {
+            const titleParam = node.querySelector('ac\\:parameter[ac\\:name="title"]');
+            const title = titleParam?.textContent || 'Details';
+            const richTextBody = node.querySelector('ac\\:rich-text-body');
+            const bodyContent = richTextBody?.textContent || content;
+            return '\n**' + title + '**\n\n' + bodyContent + '\n\n';
+        },
+    });
+    // Confluence Quote Macro
+    turndownService.addRule('confluenceQuoteMacro', {
+        filter: function (node) {
+            return (node.nodeName === 'AC:STRUCTURED-MACRO' &&
+                node.getAttribute('ac:name') === 'quote');
+        },
+        replacement: function (content, node) {
+            const richTextBody = node.querySelector('ac\\:rich-text-body');
+            const bodyContent = richTextBody?.textContent || content;
+            return '\n> ' + bodyContent.trim().split('\n').join('\n> ') + '\n\n';
+        },
+    });
+    // Confluence Rich Text Body (nested content container)
+    turndownService.addRule('confluenceRichTextBody', {
+        filter: function (node) {
+            return node.nodeName === 'AC:RICH-TEXT-BODY';
+        },
+        replacement: function (content) {
+            return content;
+        },
+    });
+    // Confluence Plain Text Body (nested content container)
+    turndownService.addRule('confluencePlainTextBody', {
+        filter: function (node) {
+            return node.nodeName === 'AC:PLAIN-TEXT-BODY';
+        },
+        replacement: function (content) {
+            return content;
+        },
+    });
+    // Confluence Links (internal page links)
+    turndownService.addRule('confluenceLinks', {
+        filter: function (node) {
+            return node.nodeName === 'AC:LINK';
+        },
+        replacement: function (content, node) {
+            // Try to extract link target
+            const element = node;
+            const pageRef = element.querySelector('ri\\:page');
+            const urlRef = element.querySelector('ri\\:url');
+            const linkBody = element.querySelector('ac\\:link-body, ac\\:plain-text-link-body');
+            const linkText = linkBody?.textContent || content || 'link';
+            const href = pageRef?.getAttribute('ri:content-title') ||
+                urlRef?.getAttribute('ri:value') ||
+                element.getAttribute('ac:anchor') || '';
+            if (href) {
+                return '[' + linkText + '](' + href + ')';
+            }
+            return linkText;
+        },
+    });
+    // Confluence Status Macro (status labels)
+    turndownService.addRule('confluenceStatusMacro', {
+        filter: function (node) {
+            return (node.nodeName === 'AC:STRUCTURED-MACRO' &&
+                node.getAttribute('ac:name') === 'status');
+        },
+        replacement: function (content, node) {
+            const titleParam = node.querySelector('ac\\:parameter[ac\\:name="title"]');
+            const title = titleParam?.textContent || 'Status';
+            const colorParam = node.querySelector('ac\\:parameter[ac\\:name="colour"]');
+            const color = colorParam?.textContent || '';
+            return '**[' + title + ']**' + (color ? ' (' + color + ')' : '');
+        },
+    });
+    // Confluence Anchor (page anchors/bookmarks)
+    turndownService.addRule('confluenceAnchor', {
+        filter: function (node) {
+            return (node.nodeName === 'AC:STRUCTURED-MACRO' &&
+                node.getAttribute('ac:name') === 'anchor');
+        },
+        replacement: function (content, node) {
+            const anchorParam = node.querySelector('ac\\:parameter');
+            const anchorName = anchorParam?.textContent || '';
+            return anchorName ? '<a name="' + anchorName + '"></a>' : '';
+        },
+    });
+    // Confluence JIRA Macro (embedded JIRA issues)
+    turndownService.addRule('confluenceJiraMacro', {
+        filter: function (node) {
+            return (node.nodeName === 'AC:STRUCTURED-MACRO' &&
+                node.getAttribute('ac:name') === 'jira');
+        },
+        replacement: function (content, node) {
+            // Extract JIRA parameters
+            const element = node;
+            const serverParam = element.querySelector('ac\\:parameter[ac\\:name="server"]');
+            const keyParam = element.querySelector('ac\\:parameter[ac\\:name="key"]');
+            const jiraKey = keyParam?.textContent || '';
+            const serverName = serverParam?.textContent || '';
+            if (jiraKey) {
+                return `\n**JIRA Issue:** ${jiraKey}${serverName ? ` (${serverName})` : ''}\n\n`;
+            }
+            return '';
+        },
+    });
+    // Generic handler for unknown Confluence macros
+    // Only catches macros that haven't been handled by specific rules above
+    turndownService.addRule('confluenceUnknownMacros', {
+        filter: function (node) {
+            if (node.nodeName !== 'AC:STRUCTURED-MACRO')
+                return false;
+            const macroName = node.getAttribute('ac:name');
+            // List of known/handled macros - skip these
+            const knownMacros = [
+                'code', 'info', 'note', 'tip', 'warning', 'panel',
+                'toc', 'excerpt', 'expand', 'quote', 'status', 'anchor', 'jira'
+            ];
+            return !knownMacros.includes(macroName || '');
+        },
+        replacement: function (content, node) {
+            const element = node;
+            const macroName = element.getAttribute('ac:name') || 'unknown';
+            console.warn(`Unknown Confluence macro: ${macroName}`);
+            // Try to extract any text content from the macro
+            const richTextBody = element.querySelector('ac\\:rich-text-body');
+            const plainTextBody = element.querySelector('ac\\:plain-text-body');
+            return richTextBody?.textContent || plainTextBody?.textContent || content || '';
+        },
+    });
+}

package/dist/src/tools/confluence-search.tool.js

@@ -0,0 +1,152 @@
+import { tool } from '@langchain/core/tools';
+import { z } from 'zod';
+/**
+ * Create Confluence agent tool for searching the knowledge base
+ * Supports semantic search with optional metadata filtering
+ */
+export function createConfluenceAgentTool(vectorStore) {
+    const schema = z.object({
+        query: z.string().describe("Semantic search query for Confluence knowledge base"),
+        filters: z.object({
+            keywords: z.array(z.string()).optional()
+                .describe("Filter by Confluence labels (e.g., ['shopware', 'deployment'])"),
+            content_type: z.enum(['project-info', 'faq', 'guide', 'decision', 'template']).optional()
+                .describe("Type of content to search"),
+            customer: z.string().optional()
+                .describe("Filter by customer name (e.g., 'customer-xyz')"),
+            category: z.enum(['active', 'maintenance', 'legacy', 'archived']).optional()
+                .describe("Project/content lifecycle category"),
+            space_key: z.string().optional()
+                .describe("Confluence space key to search within"),
+            chunk_type: z.enum(['section', 'full_page']).optional()
+                .describe("Type of content chunk (section or full_page)"),
+            has_code_blocks: z.boolean().optional()
+                .describe("Filter for content with code examples"),
+            has_tables: z.boolean().optional()
+                .describe("Filter for content with tables"),
+            has_links: z.boolean().optional()
+                .describe("Filter for content with links"),
+            min_word_count: z.number().optional()
+                .describe("Minimum word count for content"),
+            last_updated_by: z.string().optional()
+                .describe("Filter by author user ID"),
+            page_creator: z.string().optional()
+                .describe("Filter by page creator user ID"),
+            parent_page_id: z.string().optional()
+                .describe("Filter by parent page ID (child pages only)")
+        }).optional().describe("Optional metadata filters to narrow search results")
+    });
+    return tool(async ({ query, filters }) => {
+        try {
+            console.log(`\n🔍 Confluence Agent searching: "${query}"`);
+            if (filters) {
+                console.log(`   Filters:`, filters);
+            }
+            // Build metadata filter for vector store
+            const metadataFilter = {
+                source: 'confluence'
+            };
+            if (filters?.keywords && filters.keywords.length > 0) {
+                metadataFilter.labels = { arrayContains: filters.keywords };
+            }
+            // Handle content_type filter - exclude templates and guides by default unless explicitly requested
+            if (filters?.content_type) {
+                metadataFilter.content_type = filters.content_type;
+            }
+            else {
+                // Exclude both 'template' and 'guide' by default
+                metadataFilter.content_type = { notIn: ['template', 'guide'] };
+            }
+            if (filters?.customer) {
+                metadataFilter.customer = filters.customer;
+            }
+            if (filters?.category) {
+                metadataFilter.category = filters.category;
+            }
+            if (filters?.space_key) {
+                metadataFilter.space_key = filters.space_key;
+            }
+            if (filters?.chunk_type) {
+                metadataFilter.chunk_type = filters.chunk_type;
+            }
+            if (filters?.has_code_blocks !== undefined) {
+                metadataFilter.has_code_blocks = filters.has_code_blocks;
+            }
+            if (filters?.has_tables !== undefined) {
+                metadataFilter.has_tables = filters.has_tables;
+            }
+            if (filters?.has_links !== undefined) {
+                metadataFilter.has_links = filters.has_links;
+            }
+            if (filters?.min_word_count !== undefined) {
+                metadataFilter.word_count = { gte: filters.min_word_count };
+            }
+            if (filters?.last_updated_by) {
+                metadataFilter.last_updated_by = filters.last_updated_by;
+            }
+            if (filters?.page_creator) {
+                metadataFilter.page_creator = filters.page_creator;
+            }
+            if (filters?.parent_page_id) {
+                metadataFilter.parent_page_id = filters.parent_page_id;
+            }
+            // Perform vector search with scores
+            const resultsWithScores = await vectorStore.similaritySearchWithScore(query, 5, Object.keys(metadataFilter).length > 0 ? metadataFilter : undefined);
+            console.log(`   Found ${resultsWithScores.length} results`);
+            // Calculate similarity metrics
+            const scores = resultsWithScores.map(r => r.score);
+            const avgSimilarity = scores.length > 0
+                ? scores.reduce((sum, score) => sum + score, 0) / scores.length
+                : 0;
+            // Calculate variance (measure of score consistency)
+            // Example: If scores are [0.8, 0.6, 0.9] and avgSimilarity is 0.767:
+            // - (0.8 - 0.767)² + (0.6 - 0.767)² + (0.9 - 0.767)² = 0.033
+            // - 0.033 / 3 = 0.011 (variance)
+            const scoreVariance = scores.length > 1
+                ? scores.reduce((sum, score) => sum + Math.pow(score - avgSimilarity, 2), 0) / scores.length
+                : 0;
+            console.log(`   Avg similarity: ${avgSimilarity.toFixed(3)}, Variance: ${scoreVariance.toFixed(3)}`);
+            // Format results for LLM
+            const formattedResults = resultsWithScores.map(({ document }) => {
+                return {
+                    content: document.pageContent,
+                    metadata: document.metadata
+                };
+            });
+            const result = {
+                documents: formattedResults,
+                searchQuery: query,
+                filters: filters || {},
+                resultCount: resultsWithScores.length,
+                avgSimilarity,
+                scoreVariance
+            };
+            // Return as string for createReactAgent compatibility
+            return JSON.stringify(result, null, 2);
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            console.error(`❌ Confluence Agent error:`, errorMessage);
+            const errorResult = {
+                error: true,
+                message: `Tool execution failed. ${errorMessage}`,
+                query,
+                filters: filters || {},
+                suggestion: 'Please check your input parameters and try again with a simpler query or different filters.'
+            };
+            return JSON.stringify(errorResult, null, 2);
+        }
+    }, {
+        name: "confluence_agent",
+        description: `Search Confluence knowledge base for implicit organizational knowledge including:
+- Deployment rules and procedures
+- Team contacts and expertise areas
+- Project mappings (GitLab ↔ Jira ↔ Customer)
+- Historical technical decisions
+- Approved FAQs and documentation
+- Business rules and constraints
+
+Supports semantic search with lots of metadata filters which need to be used for precise targeting.`,
+        schema
+    });
+}

package/dist/src/tools/get-current-date.tool.js

@@ -0,0 +1,18 @@
+import { tool } from '@langchain/core/tools';
+import { z } from 'zod';
+export function createGetCurrentDateTool() {
+    const getCurrentDateSchema = z.object({});
+    return tool(() => {
+        const currentDate = new Date();
+        const year = currentDate.getFullYear();
+        const month = (currentDate.getMonth() + 1).toString().padStart(2, '0');
+        const day = currentDate.getDate().toString().padStart(2, '0');
+        const formattedDate = `${year}-${month}-${day}`;
+        console.log(`\n📅 Returning current date: ${formattedDate}`);
+        return formattedDate;
+    }, {
+        name: 'get_current_date',
+        description: 'Returns the current date in YYYY-MM-DD format. Use this tool when the user asks a question that requires knowledge of the current date, such as "in the last week" or "since yesterday".',
+        schema: getCurrentDateSchema,
+    });
+}

package/dist/src/vectorstore/postgres.provider.js

@@ -0,0 +1,95 @@
+import { PGVectorStore } from '@langchain/community/vectorstores/pgvector';
+import { Pool } from 'pg';
+/**
+ * Test PostgreSQL database connection
+ * @throws Error if connection fails
+ */
+export async function testPostgresConnection(config) {
+    const pool = new Pool({
+        host: config.host,
+        port: config.port,
+        user: config.user,
+        password: config.password,
+        database: config.database,
+    });
+    try {
+        await pool.query('SELECT 1');
+    }
+    finally {
+        await pool.end();
+    }
+}
+export async function createPostgresVectorStore(embeddings, documents, config) {
+    console.log('Creating PostgreSQL vector store...');
+    const poolConfig = {
+        host: config.host,
+        port: config.port,
+        user: config.user,
+        password: config.password,
+        database: config.database,
+    };
+    const pgVectorStore = await PGVectorStore.initialize(embeddings, {
+        postgresConnectionOptions: poolConfig,
+        tableName: config.tableName,
+        columns: {
+            idColumnName: 'id',
+            vectorColumnName: 'embedding',
+            contentColumnName: 'content',
+            metadataColumnName: 'metadata',
+        },
+    });
+    // Delete existing documents with the same document_id before inserting
+    if (documents.length > 0) {
+        // Collect all unique document_ids from the documents array
+        const documentIds = new Set();
+        for (const doc of documents) {
+            if (doc.metadata?.document_id) {
+                documentIds.add(String(doc.metadata.document_id));
+            }
+        }
+        if (documentIds.size > 0) {
+            const pool = new Pool(poolConfig);
+            try {
+                const documentIdsArray = Array.from(documentIds);
+                const result = await pool.query(`DELETE FROM ${config.tableName} WHERE metadata->>'document_id' = ANY($1)`, [documentIdsArray]);
+                console.log(`Deleted ${result.rowCount} existing chunks for ${documentIds.size} document(s): ${documentIdsArray.join(', ')}`);
+            }
+            finally {
+                await pool.end();
+            }
+        }
+        await pgVectorStore.addDocuments(documents);
+    }
+    console.log('PostgreSQL vector store created');
+    // Wrap PGVectorStore to match VectorStoreProvider interface
+    return {
+        async addDocuments(docs) {
+            await pgVectorStore.addDocuments(docs);
+        },
+        async similaritySearch(query, k, filter) {
+            // If filter is a metadata object, pass it to pgvector's native filter
+            if (filter && typeof filter === 'object' && !('call' in filter)) {
+                return await pgVectorStore.similaritySearch(query, k, filter);
+            }
+            // If filter is a function, apply it to results
+            const results = await pgVectorStore.similaritySearch(query, k);
+            return (filter && typeof filter === 'function') ? results.filter(filter) : results;
+        },
+        async similaritySearchWithScore(query, k, filter) {
+            // If filter is a metadata object, pass it to pgvector's native filter
+            if (filter && typeof filter === 'object' && !('call' in filter)) {
+                const results = await pgVectorStore.similaritySearchWithScore(query, k, filter);
+                return results.map(([document, score]) => ({ document, score }));
+            }
+            // If filter is a function, apply it to results
+            const results = await pgVectorStore.similaritySearchWithScore(query, k);
+            const mapped = results.map(([document, score]) => ({ document, score }));
+            return (filter && typeof filter === 'function')
+                ? mapped.filter(item => filter(item.document))
+                : mapped;
+        },
+        async cleanup() {
+            await pgVectorStore.end();
+        },
+    };
+}

package/dist/src/vectorstore/vectorstore.interface.js

@@ -0,0 +1 @@
+export {};