stellavault 0.2.0 → 0.3.0

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/adaptive.d.ts

@@ -0,0 +1,16 @@
+import type { SearchEngine } from './index.js';
+import type { SearchResult, SearchOptions } from '../types/search.js';
+export interface SearchContext {
+    recentSearches?: string[];
+    recentDocTags?: string[];
+    currentFilePath?: string;
+}
+export interface AdaptiveSearchEngine extends SearchEngine {
+    search(options: SearchOptions & {
+        context?: SearchContext;
+    }): Promise<SearchResult[]>;
+}
+export declare function createAdaptiveSearch(deps: {
+    baseSearch: SearchEngine;
+}): AdaptiveSearchEngine;
+//# sourceMappingURL=adaptive.d.ts.map

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

@@ -0,0 +1,67 @@
+// Design Ref: §4.1 — 컨텍스트 수집 + reranking
+// Plan SC: SC-05 NDCG 15%+ 향상, SC-06 기존 116 tests 통과
+export function createAdaptiveSearch(deps) {
+    const { baseSearch } = deps;
+    // In-memory context (session-scoped)
+    const searchHistory = [];
+    const recentTags = [];
+    return {
+        async search(options) {
+            const { context, ...baseOptions } = options;
+            // 1. Base search
+            const results = await baseSearch.search(baseOptions);
+            // 2. No context → return as-is (backwards compatible)
+            if (!context && searchHistory.length === 0)
+                return results;
+            // 3. Build effective context
+            const ctx = {
+                recentSearches: context?.recentSearches ?? searchHistory.slice(-5),
+                recentDocTags: context?.recentDocTags ?? recentTags.slice(-10),
+                currentFilePath: context?.currentFilePath,
+            };
+            // 4. Rerank based on context
+            const reranked = results.map((r) => {
+                let boost = 0;
+                // Tag overlap boost (0 ~ 0.3)
+                const docTags = ctx.recentDocTags ?? [];
+                if (docTags.length > 0 && r.document.tags.length > 0) {
+                    const docTagSet = new Set(r.document.tags);
+                    const overlap = docTags.filter((t) => docTagSet.has(t)).length;
+                    boost += Math.min(overlap / Math.max(docTags.length, 1), 1) * 0.3;
+                }
+                // File path proximity boost (0 ~ 0.2)
+                if (ctx.currentFilePath && r.document.filePath) {
+                    const ctxParts = ctx.currentFilePath.split('/');
+                    const docParts = r.document.filePath.split('/');
+                    let common = 0;
+                    for (let i = 0; i < Math.min(ctxParts.length, docParts.length); i++) {
+                        if (ctxParts[i] === docParts[i])
+                            common++;
+                        else
+                            break;
+                    }
+                    if (common > 0) {
+                        boost += Math.min(common / Math.max(ctxParts.length - 1, 1), 1) * 0.2;
+                    }
+                }
+                return { ...r, score: r.score * (1 + boost) };
+            });
+            // 5. Re-sort
+            reranked.sort((a, b) => b.score - a.score);
+            // 6. Update history
+            searchHistory.push(options.query);
+            if (searchHistory.length > 20)
+                searchHistory.shift();
+            // Track tags from top results for future context
+            for (const r of reranked.slice(0, 3)) {
+                for (const t of r.document.tags) {
+                    recentTags.push(t);
+                }
+            }
+            while (recentTags.length > 30)
+                recentTags.shift();
+            return reranked;
+        },
+    };
+}
+//# sourceMappingURL=adaptive.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,15 @@
+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 { createAdaptiveSearch } from './adaptive.js';
+export type { SearchContext, AdaptiveSearchEngine } from './adaptive.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

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

@@ -0,0 +1,64 @@
+// Design Ref: §4.2 — createSearchEngine
+import { searchBm25 } from './bm25.js';
+import { searchSemantic } from './semantic.js';
+import { rrfFusion } from './rrf.js';
+export { rrfFusion } from './rrf.js';
+export { createAdaptiveSearch } from './adaptive.js';
+export function createSearchEngine(deps) {
+    const { store, embedder, rrfK = 60 } = deps;
+    const FETCH_LIMIT = 30; // 각 검색에서 가져올 후보 수
+    return {
+        async search(options) {
+            const { query, limit = 10, threshold = 0.0, tags } = options;
+            // 병렬로 BM25 + Semantic 검색
+            const [bm25Results, semanticResults] = await Promise.all([
+                searchBm25(store, query, FETCH_LIMIT),
+                searchSemantic(store, embedder, query, FETCH_LIMIT),
+            ]);
+            // RRF Fusion
+            const fused = rrfFusion(semanticResults, bm25Results, rrfK, limit * 2);
+            // 청크+문서 조회 + 필터링
+            const results = [];
+            for (const scored of fused) {
+                if (scored.score < threshold)
+                    continue;
+                const chunk = await store.getChunk(scored.chunkId);
+                if (!chunk)
+                    continue;
+                const document = await store.getDocument(chunk.documentId);
+                if (!document)
+                    continue;
+                // 태그 필터
+                if (tags && tags.length > 0) {
+                    const docTags = new Set(document.tags);
+                    if (!tags.some(t => docTags.has(t)))
+                        continue;
+                }
+                results.push({
+                    chunk,
+                    document,
+                    score: scored.score,
+                    highlights: extractHighlights(chunk.content, query),
+                });
+                if (results.length >= limit)
+                    break;
+            }
+            return results;
+        },
+    };
+}
+function extractHighlights(content, query) {
+    const words = query.toLowerCase().split(/\s+/).filter(w => w.length > 1);
+    const lines = content.split('\n');
+    const highlights = [];
+    for (const line of lines) {
+        const lower = line.toLowerCase();
+        if (words.some(w => lower.includes(w))) {
+            highlights.push(line.trim());
+            if (highlights.length >= 3)
+                break;
+        }
+    }
+    return highlights;
+}
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,7 @@
+import type { ScoredChunk } from '../types/chunk.js';
+/**
+ * RRF: 두 랭킹 리스트를 통합하여 최종 점수를 산출합니다.
+ * score(d) = Σ 1/(k + rank_i) for each ranker i
+ */
+export declare function rrfFusion(listA: ScoredChunk[], listB: ScoredChunk[], k?: number, limit?: number): ScoredChunk[];
+//# sourceMappingURL=rrf.d.ts.map

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

@@ -0,0 +1,21 @@
+// Design Ref: §6.2 — Reciprocal Rank Fusion (k=60)
+/**
+ * RRF: 두 랭킹 리스트를 통합하여 최종 점수를 산출합니다.
+ * score(d) = Σ 1/(k + rank_i) for each ranker i
+ */
+export function rrfFusion(listA, listB, k = 60, limit = 10) {
+    const scores = new Map();
+    for (let i = 0; i < listA.length; i++) {
+        const id = listA[i].chunkId;
+        scores.set(id, (scores.get(id) ?? 0) + 1 / (k + i + 1));
+    }
+    for (let i = 0; i < listB.length; i++) {
+        const id = listB[i].chunkId;
+        scores.set(id, (scores.get(id) ?? 0) + 1 / (k + i + 1));
+    }
+    return [...scores.entries()]
+        .sort((a, b) => b[1] - a[1])
+        .slice(0, limit)
+        .map(([chunkId, score]) => ({ chunkId, score }));
+}
+//# sourceMappingURL=rrf.js.map

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

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

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

@@ -0,0 +1,6 @@
+// Design Ref: §6.2 — 시맨틱 벡터 검색
+export async function searchSemantic(store, embedder, query, limit) {
+    const embedding = await embedder.embed(query);
+    return store.searchSemantic(embedding, limit);
+}
+//# sourceMappingURL=semantic.js.map

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

@@ -1,2 +1,3 @@
 export type { VectorStore } from './types.js';
 export { createSqliteVecStore, upsertDocument } from './sqlite-vec.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,2 @@
+export { createSqliteVecStore, upsertDocument } from './sqlite-vec.js';
+//# sourceMappingURL=index.js.map

package/packages/core/dist/store/sqlite-vec.d.ts

@@ -0,0 +1,6 @@
+import Database from 'better-sqlite3';
+import type { VectorStore } from './types.js';
+import type { Document } from '../types/index.js';
+export declare function createSqliteVecStore(dbPath: string, dimensions?: number): VectorStore;
+export declare function upsertDocument(db: Database.Database, doc: Document): void;
+//# sourceMappingURL=sqlite-vec.d.ts.map