stellavault 0.1.0 → 0.2.1

package/packages/core/dist/pack/creator.js

@@ -0,0 +1,105 @@
+// Design Ref: Phase 3 FR-01~03 — 검색/클러스터 기반 팩 생성
+import { maskPII } from './pii-masker.js';
+export async function createPack(store, searchEngine, embedder, options) {
+    const { name, author = 'anonymous', license = 'CC-BY-4.0', description = '', limit = 100 } = options;
+    let chunkIds = [];
+    if (options.fromSearch) {
+        // 검색 결과에서 청크 수집
+        const results = await searchEngine.search({ query: options.fromSearch, limit });
+        chunkIds = results.map(r => r.chunk.id);
+    }
+    else if (options.fromCluster !== undefined) {
+        // 클러스터의 문서에서 청크 수집
+        const docs = await store.getAllDocuments();
+        const embeddings = await store.getDocumentEmbeddings();
+        // 간단한 클러스터 매칭: graph-data의 K-means 결과를 재활용할 수 없으므로
+        // 해당 클러스터 문서의 모든 청크를 가져옴
+        // 여기서는 fromSearch를 권장하되, fromCluster는 문서 ID 기반으로 처리
+        const clusterDocs = docs.slice(0, limit);
+        for (const doc of clusterDocs) {
+            const chunk = await store.getChunk(`${doc.id}#0`);
+            if (chunk)
+                chunkIds.push(chunk.id);
+        }
+    }
+    // 청크 데이터 수집 + PII 마스킹
+    const chunks = [];
+    let totalRedacted = 0;
+    const allTypes = new Set();
+    for (const chunkId of chunkIds) {
+        const chunk = await store.getChunk(chunkId);
+        if (!chunk)
+            continue;
+        const doc = await store.getDocument(chunk.documentId);
+        if (!doc)
+            continue;
+        // PII 마스킹
+        const { masked, redactedCount, redactedTypes } = maskPII(chunk.content);
+        totalRedacted += redactedCount;
+        redactedTypes.forEach(t => allTypes.add(t));
+        // 임베딩 재생성 (마스킹된 텍스트로)
+        const embedding = await embedder.embed(masked);
+        chunks.push({
+            id: chunkId,
+            content: masked,
+            heading: chunk.heading,
+            embedding,
+            metadata: {
+                sourceFile: doc.filePath,
+                category: detectCategory(doc.filePath, chunk.content),
+                language: detectLanguage(chunk.content),
+            },
+        });
+    }
+    const pack = {
+        name,
+        version: '1.0.0',
+        author,
+        license,
+        description: description || `Knowledge pack: ${name}`,
+        tags: extractPackTags(chunks),
+        embeddingModel: embedder.modelName,
+        embeddingDimensions: embedder.dimensions,
+        schemaVersion: '1.0',
+        chunks,
+        createdAt: new Date().toISOString(),
+    };
+    return {
+        pack,
+        piiReport: { redactedCount: totalRedacted, types: [...allTypes] },
+    };
+}
+function detectCategory(filePath, content) {
+    const lower = filePath.toLowerCase() + ' ' + content.slice(0, 200).toLowerCase();
+    if (lower.includes('lesson') || lower.includes('교훈'))
+        return 'lesson';
+    if (lower.includes('pattern') || lower.includes('패턴'))
+        return 'pattern';
+    if (lower.includes('decision') || lower.includes('결정'))
+        return 'decision';
+    if (lower.includes('design') || lower.includes('설계'))
+        return 'reference';
+    return 'reference';
+}
+function detectLanguage(content) {
+    if (content.includes('typescript') || content.includes('.ts'))
+        return 'typescript';
+    if (content.includes('python') || content.includes('.py'))
+        return 'python';
+    if (content.includes('react') || content.includes('jsx'))
+        return 'react';
+    return undefined;
+}
+function extractPackTags(chunks) {
+    const wordCounts = new Map();
+    for (const c of chunks) {
+        const words = c.heading.split(/\s+/).filter(w => w.length > 2);
+        for (const w of words)
+            wordCounts.set(w, (wordCounts.get(w) ?? 0) + 1);
+    }
+    return [...wordCounts.entries()]
+        .sort((a, b) => b[1] - a[1])
+        .slice(0, 10)
+        .map(([w]) => w);
+}
+//# sourceMappingURL=creator.js.map

package/packages/core/dist/pack/exporter.d.ts

@@ -0,0 +1,4 @@
+import type { KnowledgePack } from './types.js';
+export declare function exportPack(pack: KnowledgePack, outputPath: string): void;
+export declare function packToSummary(pack: KnowledgePack): string;
+//# sourceMappingURL=exporter.d.ts.map

package/packages/core/dist/pack/exporter.js

@@ -0,0 +1,18 @@
+// Design Ref: Phase 3 FR-05 — .sv-pack 파일 내보내기
+import { writeFileSync, mkdirSync } from 'node:fs';
+import { dirname } from 'node:path';
+export function exportPack(pack, outputPath) {
+    mkdirSync(dirname(outputPath), { recursive: true });
+    writeFileSync(outputPath, JSON.stringify(pack, null, 2), 'utf-8');
+}
+export function packToSummary(pack) {
+    return [
+        `Name: ${pack.name} v${pack.version}`,
+        `Author: ${pack.author} (${pack.license})`,
+        `Chunks: ${pack.chunks.length}`,
+        `Model: ${pack.embeddingModel} (${pack.embeddingDimensions}d)`,
+        `Tags: ${pack.tags.join(', ')}`,
+        `Created: ${pack.createdAt}`,
+    ].join('\n');
+}
+//# sourceMappingURL=exporter.js.map

package/packages/core/dist/pack/importer.d.ts

@@ -0,0 +1,10 @@
+import type { VectorStore } from '../store/types.js';
+import type { Embedder } from '../indexer/embedder.js';
+export interface ImportResult {
+    imported: number;
+    skipped: number;
+    reEmbedded: number;
+    modelMismatch: boolean;
+}
+export declare function importPack(store: VectorStore, embedder: Embedder, filePath: string): Promise<ImportResult>;
+//# sourceMappingURL=importer.d.ts.map

package/packages/core/dist/pack/importer.js

@@ -0,0 +1,55 @@
+// Design Ref: Phase 3 FR-06~07 — .sv-pack 가져오기 + 벡터 DB 병합
+import { readFileSync } from 'node:fs';
+export async function importPack(store, embedder, filePath) {
+    const raw = readFileSync(filePath, 'utf-8');
+    const pack = JSON.parse(raw);
+    // 임베딩 모델 불일치 감지
+    const modelMismatch = pack.embeddingModel !== embedder.modelName ||
+        pack.embeddingDimensions !== embedder.dimensions;
+    let imported = 0;
+    let skipped = 0;
+    let reEmbedded = 0;
+    // 팩 문서를 pack_{name} prefix로 저장
+    const packDocId = `pack_${pack.name}`;
+    await store.upsertDocument({
+        id: packDocId,
+        filePath: `[pack] ${pack.name}`,
+        title: `${pack.name} (Knowledge Pack)`,
+        content: `Imported pack: ${pack.description}\nChunks: ${pack.chunks.length}\nAuthor: ${pack.author}`,
+        frontmatter: { pack: pack.name, license: pack.license },
+        tags: pack.tags,
+        lastModified: pack.createdAt,
+        contentHash: `pack_${pack.name}_${pack.version}`,
+    });
+    const chunks = [];
+    for (let i = 0; i < pack.chunks.length; i++) {
+        const pc = pack.chunks[i];
+        let embedding = pc.embedding;
+        // 모델 불일치 시 재임베딩
+        if (modelMismatch) {
+            embedding = await embedder.embed(pc.content);
+            reEmbedded++;
+        }
+        // 차원 검증
+        if (embedding.length !== embedder.dimensions) {
+            skipped++;
+            continue;
+        }
+        chunks.push({
+            id: `${packDocId}#${i}`,
+            documentId: packDocId,
+            content: pc.content,
+            heading: pc.heading || pack.name,
+            startLine: 0,
+            endLine: 0,
+            tokenCount: Math.ceil(pc.content.length / 4),
+            embedding,
+        });
+        imported++;
+    }
+    if (chunks.length > 0) {
+        await store.upsertChunks(chunks);
+    }
+    return { imported, skipped, reEmbedded, modelMismatch };
+}
+//# sourceMappingURL=importer.js.map

package/packages/core/{src/pack/index.ts → dist/pack/index.d.ts}

@@ -3,3 +3,4 @@ export { createPack, type CreatePackOptions } from './creator.js';
 export { exportPack, packToSummary } from './exporter.js';
 export { importPack, type ImportResult } from './importer.js';
 export { maskPII, type MaskResult } from './pii-masker.js';
+//# sourceMappingURL=index.d.ts.map

package/packages/core/dist/pack/index.js

@@ -0,0 +1,5 @@
+export { createPack } from './creator.js';
+export { exportPack, packToSummary } from './exporter.js';
+export { importPack } from './importer.js';
+export { maskPII } from './pii-masker.js';
+//# sourceMappingURL=index.js.map

package/packages/core/dist/pack/marketplace.d.ts

@@ -0,0 +1,14 @@
+export interface PackListing {
+    name: string;
+    version: string;
+    description: string;
+    author: string;
+    downloads?: number;
+    tags: string[];
+    source: 'npm' | 'github';
+    installCommand: string;
+}
+export declare function searchMarketplace(query: string, limit?: number): Promise<PackListing[]>;
+export declare function createPackageJson(packName: string, description: string, author: string, version?: string): string;
+export declare function getPublishInstructions(packName: string): string;
+//# sourceMappingURL=marketplace.d.ts.map

package/packages/core/dist/pack/marketplace.js

@@ -0,0 +1,90 @@
+// Pack Marketplace (F-A07) — npm registry + GitHub Releases 기반
+// 서버 불필요: npm/GitHub를 마켓플레이스로 활용
+// npm에서 @stellavault/pack-* 패키지 검색
+export async function searchMarketplace(query, limit = 10) {
+    const results = [];
+    try {
+        // npm registry search
+        const safeLimit = Math.min(limit, 20); // MED: 최대 20개 제한
+        const npmUrl = `https://registry.npmjs.org/-/v1/search?text=stellavault-pack+${encodeURIComponent(query)}&size=${safeLimit}`;
+        const res = await fetch(npmUrl, { signal: AbortSignal.timeout(5000) });
+        if (res.ok) {
+            const data = await res.json();
+            for (const pkg of data.objects ?? []) {
+                results.push({
+                    name: pkg.package.name,
+                    version: pkg.package.version,
+                    description: pkg.package.description ?? '',
+                    author: pkg.package.author?.name ?? pkg.package.publisher?.username ?? 'unknown',
+                    downloads: pkg.downloads?.weekly ?? 0,
+                    tags: pkg.package.keywords ?? [],
+                    source: 'npm',
+                    installCommand: `npm install ${pkg.package.name}`,
+                });
+            }
+        }
+    }
+    catch { /* npm search failed — continue */ }
+    try {
+        // GitHub search for stellavault-pack repos
+        const ghUrl = `https://api.github.com/search/repositories?q=stellavault-pack+${encodeURIComponent(query)}&per_page=${limit}`;
+        const res = await fetch(ghUrl, {
+            headers: { 'Accept': 'application/vnd.github.v3+json', 'User-Agent': 'stellavault-marketplace' },
+            signal: AbortSignal.timeout(5000),
+        });
+        if (res.ok) {
+            const data = await res.json();
+            for (const repo of data.items ?? []) {
+                // npm과 중복 방지
+                if (results.some(r => r.name === repo.name))
+                    continue;
+                results.push({
+                    name: repo.full_name,
+                    version: 'latest',
+                    description: repo.description ?? '',
+                    author: repo.owner?.login ?? 'unknown',
+                    downloads: repo.stargazers_count,
+                    tags: repo.topics ?? [],
+                    source: 'github',
+                    installCommand: `sv pack import <(curl -sL ${repo.html_url}/releases/latest/download/pack.sv-pack)`,
+                });
+            }
+        }
+    }
+    catch { /* GitHub search failed — continue */ }
+    return results;
+}
+// sv-pack 파일을 npm에 publish할 수 있도록 패키지 생성
+export function createPackageJson(packName, description, author, version = '1.0.0') {
+    return JSON.stringify({
+        name: `stellavault-pack-${packName}`,
+        version,
+        description,
+        author,
+        license: 'CC-BY-4.0',
+        keywords: ['stellavault', 'knowledge-pack', packName],
+        files: ['*.sv-pack', 'README.md'],
+        stellavault: { type: 'knowledge-pack' },
+    }, null, 2);
+}
+// GitHub Release로 pack 배포용 명령어 생성
+export function getPublishInstructions(packName) {
+    return `
+To publish your Knowledge Pack:
+
+Option A: npm
+  1. cd your-pack-directory/
+  2. npm init (or use: sv pack prepare ${packName})
+  3. npm publish
+
+Option B: GitHub Release
+  1. Create a GitHub repo: stellavault-pack-${packName}
+  2. Add your .sv-pack file
+  3. Create a release with the .sv-pack as an asset
+
+Users install with:
+  npm: sv pack install stellavault-pack-${packName}
+  GitHub: sv pack import <url-to-sv-pack-file>
+`.trim();
+}
+//# sourceMappingURL=marketplace.js.map

package/packages/core/dist/pack/pii-masker.d.ts

@@ -0,0 +1,7 @@
+export interface MaskResult {
+    masked: string;
+    redactedCount: number;
+    redactedTypes: string[];
+}
+export declare function maskPII(text: string): MaskResult;
+//# sourceMappingURL=pii-masker.d.ts.map

package/packages/core/dist/pack/pii-masker.js

@@ -0,0 +1,29 @@
+// Design Ref: Phase 3 FR-04 — PII 감지 + 마스킹
+const PII_PATTERNS = [
+    { name: 'email', regex: /[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}/g },
+    { name: 'api_key', regex: /(?:sk|pk|api|key|token|secret|password)[_\-a-zA-Z]*[_\-][a-zA-Z0-9]{16,}/gi },
+    { name: 'aws_key', regex: /AKIA[0-9A-Z]{16}/g },
+    { name: 'url_with_auth', regex: /https?:\/\/[^:]+:[^@]+@[^\s]+/g },
+    { name: 'ip_address', regex: /\b(?:\d{1,3}\.){3}\d{1,3}\b/g },
+    { name: 'phone', regex: /\b0\d{1,2}[-.\s]?\d{3,4}[-.\s]?\d{4}\b/g },
+    { name: 'jwt', regex: /eyJ[a-zA-Z0-9_-]{10,}\.[a-zA-Z0-9_-]{10,}\.[a-zA-Z0-9_-]{10,}/g },
+];
+export function maskPII(text) {
+    let masked = text;
+    let redactedCount = 0;
+    const redactedTypes = new Set();
+    for (const { name, regex } of PII_PATTERNS) {
+        const matches = masked.match(regex);
+        if (matches) {
+            redactedCount += matches.length;
+            redactedTypes.add(name);
+            masked = masked.replace(regex, `[REDACTED:${name}]`);
+        }
+    }
+    return {
+        masked,
+        redactedCount,
+        redactedTypes: [...redactedTypes],
+    };
+}
+//# sourceMappingURL=pii-masker.js.map

package/packages/core/dist/pack/types.d.ts

@@ -0,0 +1,36 @@
+export interface KnowledgePack {
+    name: string;
+    version: string;
+    author: string;
+    license: string;
+    description: string;
+    tags: string[];
+    embeddingModel: string;
+    embeddingDimensions: number;
+    schemaVersion: string;
+    chunks: PackChunk[];
+    createdAt: string;
+}
+export interface PackChunk {
+    id: string;
+    content: string;
+    heading: string;
+    embedding: number[];
+    metadata: {
+        sourceFile: string;
+        category: string;
+        language?: string;
+        framework?: string;
+    };
+}
+export interface PackInfo {
+    name: string;
+    version: string;
+    author: string;
+    license: string;
+    description: string;
+    chunkCount: number;
+    embeddingModel: string;
+    createdAt: string;
+}
+//# sourceMappingURL=types.d.ts.map

package/packages/core/dist/pack/types.js

@@ -0,0 +1,3 @@
+// Design Ref: Phase 3 §1 — .sv-pack.json 표준 포맷
+export {};
+//# sourceMappingURL=types.js.map

package/packages/core/dist/plugins/index.d.ts

@@ -0,0 +1,35 @@
+export interface PluginContext {
+    store: {
+        search(query: string, limit?: number): Promise<any[]>;
+        getDocument(id: string): Promise<any>;
+        getStats(): Promise<any>;
+    };
+    config: Record<string, unknown>;
+    log: (message: string) => void;
+}
+export type PluginEvent = 'onIndex' | 'onSearch' | 'onDecay' | 'onGapDetected' | 'onStartup' | 'onShutdown';
+export interface PluginManifest {
+    name: string;
+    version: string;
+    description: string;
+    author?: string;
+    events: PluginEvent[];
+}
+export interface StellavaultPlugin {
+    manifest: PluginManifest;
+    activate(context: PluginContext): Promise<void>;
+    deactivate?(): Promise<void>;
+    onEvent?(event: PluginEvent, data: unknown): Promise<void>;
+}
+export declare class PluginManager {
+    private plugins;
+    private handlers;
+    private context;
+    constructor(context: PluginContext);
+    register(plugin: StellavaultPlugin): Promise<void>;
+    unregister(name: string): Promise<void>;
+    emit(event: PluginEvent, data: unknown): Promise<void>;
+    listPlugins(): PluginManifest[];
+    getPlugin(name: string): StellavaultPlugin | undefined;
+}
+//# sourceMappingURL=index.d.ts.map

package/packages/core/dist/plugins/index.js

@@ -0,0 +1,57 @@
+// Plugin SDK (F-A15) — Event-driven plugin system
+export class PluginManager {
+    plugins = new Map();
+    handlers = new Map();
+    context;
+    constructor(context) {
+        this.context = context;
+    }
+    async register(plugin) {
+        if (this.plugins.has(plugin.manifest.name)) {
+            throw new Error(`Plugin "${plugin.manifest.name}" is already registered`);
+        }
+        this.plugins.set(plugin.manifest.name, plugin);
+        // Register event handlers (MED fix: track by plugin name for proper unregister)
+        for (const event of plugin.manifest.events) {
+            if (!this.handlers.has(event))
+                this.handlers.set(event, []);
+            if (plugin.onEvent) {
+                this.handlers.get(event).push({
+                    pluginName: plugin.manifest.name,
+                    handler: (data) => plugin.onEvent(event, data),
+                });
+            }
+        }
+        await plugin.activate(this.context);
+        this.context.log(`Plugin "${plugin.manifest.name}" v${plugin.manifest.version} activated`);
+    }
+    async unregister(name) {
+        const plugin = this.plugins.get(name);
+        if (!plugin)
+            return;
+        await plugin.deactivate?.();
+        this.plugins.delete(name);
+        // MED fix: properly remove handlers by plugin name
+        for (const [event, entries] of this.handlers) {
+            this.handlers.set(event, entries.filter(e => e.pluginName !== name));
+        }
+    }
+    async emit(event, data) {
+        const entries = this.handlers.get(event) ?? [];
+        for (const { handler } of entries) {
+            try {
+                await handler(data);
+            }
+            catch (err) {
+                this.context.log(`Plugin error on ${event}: ${err instanceof Error ? err.message : String(err)}`);
+            }
+        }
+    }
+    listPlugins() {
+        return [...this.plugins.values()].map(p => p.manifest);
+    }
+    getPlugin(name) {
+        return this.plugins.get(name);
+    }
+}
+//# sourceMappingURL=index.js.map

package/packages/core/dist/plugins/webhooks.d.ts

@@ -0,0 +1,30 @@
+import type { PluginEvent } from './index.js';
+export interface WebhookConfig {
+    url: string;
+    events: PluginEvent[];
+    secret?: string;
+    retries?: number;
+}
+export interface WebhookDelivery {
+    id: string;
+    event: PluginEvent;
+    url: string;
+    status: 'pending' | 'success' | 'failed';
+    attempts: number;
+    lastAttempt?: string;
+    response?: {
+        status: number;
+        body: string;
+    };
+}
+export declare class WebhookManager {
+    private configs;
+    private deliveries;
+    register(config: WebhookConfig): void;
+    unregister(url: string): void;
+    emit(event: PluginEvent, data: unknown): Promise<WebhookDelivery[]>;
+    private deliver;
+    getRecentDeliveries(limit?: number): WebhookDelivery[];
+    listWebhooks(): WebhookConfig[];
+}
+//# sourceMappingURL=webhooks.d.ts.map

package/packages/core/dist/plugins/webhooks.js

@@ -0,0 +1,79 @@
+// Webhook/Event System (F-A17)
+// Emit events on index, decay, gap detection → deliver via HTTP webhook
+export class WebhookManager {
+    configs = [];
+    deliveries = [];
+    register(config) {
+        // MED: webhook URL 검증
+        try {
+            const parsed = new URL(config.url);
+            if (!['http:', 'https:'].includes(parsed.protocol))
+                throw new Error('Invalid protocol');
+            const host = parsed.hostname.toLowerCase();
+            if (host === 'localhost' || host === '127.0.0.1' || host.startsWith('192.168.') || host.startsWith('10.')) {
+                throw new Error('Internal URLs not allowed for webhooks');
+            }
+        }
+        catch (e) {
+            throw new Error(`Invalid webhook URL: ${e instanceof Error ? e.message : e}`);
+        }
+        this.configs.push(config);
+    }
+    unregister(url) {
+        this.configs = this.configs.filter(c => c.url !== url);
+    }
+    async emit(event, data) {
+        const matching = this.configs.filter(c => c.events.includes(event));
+        const results = [];
+        for (const config of matching) {
+            const delivery = await this.deliver(config, event, data);
+            results.push(delivery);
+            this.deliveries.push(delivery);
+        }
+        // Keep last 100 deliveries
+        if (this.deliveries.length > 100) {
+            this.deliveries = this.deliveries.slice(-100);
+        }
+        return results;
+    }
+    async deliver(config, event, data) {
+        const id = `wh-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+        const maxRetries = config.retries ?? 3;
+        const delivery = { id, event, url: config.url, status: 'pending', attempts: 0 };
+        const payload = JSON.stringify({ event, data, timestamp: new Date().toISOString(), source: 'stellavault' });
+        for (let attempt = 0; attempt <= maxRetries; attempt++) {
+            delivery.attempts = attempt + 1;
+            delivery.lastAttempt = new Date().toISOString();
+            try {
+                const headers = { 'Content-Type': 'application/json', 'User-Agent': 'stellavault-webhook/1.0' };
+                if (config.secret) {
+                    const { createHmac } = await import('node:crypto');
+                    const sig = createHmac('sha256', config.secret).update(payload).digest('hex');
+                    headers['X-Stellavault-Signature'] = `sha256=${sig}`;
+                }
+                const res = await fetch(config.url, { method: 'POST', headers, body: payload, signal: AbortSignal.timeout(10000) });
+                delivery.response = { status: res.status, body: (await res.text()).slice(0, 500) };
+                if (res.ok) {
+                    delivery.status = 'success';
+                    return delivery;
+                }
+            }
+            catch (err) {
+                delivery.response = { status: 0, body: err instanceof Error ? err.message : String(err) };
+            }
+            // Exponential backoff
+            if (attempt < maxRetries) {
+                await new Promise(r => setTimeout(r, 1000 * Math.pow(2, attempt)));
+            }
+        }
+        delivery.status = 'failed';
+        return delivery;
+    }
+    getRecentDeliveries(limit = 20) {
+        return this.deliveries.slice(-limit).reverse();
+    }
+    listWebhooks() {
+        return [...this.configs];
+    }
+}
+//# sourceMappingURL=webhooks.js.map

package/packages/core/dist/search/bm25.d.ts

@@ -0,0 +1,4 @@
+import type { VectorStore } from '../store/types.js';
+import type { ScoredChunk } from '../types/chunk.js';
+export declare function searchBm25(store: VectorStore, query: string, limit: number): Promise<ScoredChunk[]>;
+//# sourceMappingURL=bm25.d.ts.map

package/packages/core/dist/search/bm25.js

@@ -0,0 +1,10 @@
+// Design Ref: §6.2 — BM25 키워드 검색 (FTS5)
+export async function searchBm25(store, query, limit) {
+    // FTS5 쿼리 전처리: 특수문자 제거, 공백으로 OR 검색
+    const sanitized = query.replace(/[^\w\s가-힣]/g, ' ').trim();
+    if (!sanitized)
+        return [];
+    const ftsQuery = sanitized.split(/\s+/).join(' OR ');
+    return store.searchKeyword(ftsQuery, limit);
+}
+//# sourceMappingURL=bm25.js.map

package/packages/core/dist/search/index.d.ts

@@ -0,0 +1,13 @@
+import type { Embedder } from '../indexer/embedder.js';
+import type { VectorStore } from '../store/types.js';
+import type { SearchResult, SearchOptions } from '../types/search.js';
+export { rrfFusion } from './rrf.js';
+export interface SearchEngine {
+    search(options: SearchOptions): Promise<SearchResult[]>;
+}
+export declare function createSearchEngine(deps: {
+    store: VectorStore;
+    embedder: Embedder;
+    rrfK?: number;
+}): SearchEngine;
+//# sourceMappingURL=index.d.ts.map