stellavault 0.1.0 → 0.2.1

package/packages/core/dist/index.js

@@ -0,0 +1,69 @@
+// Design Ref: §4.2 — Core Internal API (Facade)
+// Design Ref: §9.3 — Dependency Injection Pattern
+export { loadConfig } from './config.js';
+// Store
+export { createSqliteVecStore } from './store/index.js';
+// Indexer
+export { indexVault, scanVault, chunkDocument, createLocalEmbedder } from './indexer/index.js';
+// Search
+export { createSearchEngine } from './search/index.js';
+// MCP
+export { createMcpServer } from './mcp/index.js';
+// Pack (Phase 3)
+export { createPack, exportPack, importPack, packToSummary, maskPII } from './pack/index.js';
+// API (Phase 2)
+export { createApiServer } from './api/server.js';
+// Intelligence (Phase 4b)
+export { DecayEngine } from './intelligence/decay-engine.js';
+export { computeRetrievability, updateStability, estimateInitialStability, elapsedDays } from './intelligence/fsrs.js';
+export { detectDuplicates } from './intelligence/duplicate-detector.js';
+export { detectKnowledgeGaps } from './intelligence/gap-detector.js';
+export { detectContradictions } from './intelligence/contradiction-detector.js';
+export { computeSemanticDrift, findMostDrifted, hashEmbedding } from './intelligence/semantic-versioning.js';
+export { predictKnowledgeGaps } from './intelligence/predictive-gaps.js';
+export { generateLearningPath } from './intelligence/learning-path.js';
+export { checkNotifications } from './intelligence/notifications.js';
+// Multi-Vault
+export { addVault, removeVault, listVaults, getVault, searchAllVaults } from './multi-vault/index.js';
+// Voice Capture
+export { captureVoice, transcribeAudio, isWhisperAvailable } from './capture/voice.js';
+// Dashboard + PWA
+export { mountDashboard } from './api/dashboard.js';
+export { mountPWA } from './api/pwa.js';
+// Agentic Graph
+export { createAgenticGraphTools } from './mcp/tools/agentic-graph.js';
+// Cloud
+export { syncToCloud, restoreFromCloud, getSyncState, encrypt, decrypt, getOrCreateEncryptionKey } from './cloud/index.js';
+// Team
+export { inviteMember, authenticateMember, hasPermission, listMembers, removeMember, createAuthMiddleware, loadTeamConfig, generateToken } from './team/index.js';
+// Pack Marketplace
+export { searchMarketplace, createPackageJson, getPublishInstructions } from './pack/marketplace.js';
+// Federation
+export { FederationNode, FederatedSearch, getOrCreateIdentity } from './federation/index.js';
+export { vouch, revoke, block, getTrustLevel, isBlocked, listTrusted, computeTrustScore } from './federation/trust.js';
+export { loadSharingConfig, saveSharingConfig, isDocumentShareable, sanitizeSnippet, getSharingSummary, addBlockedTag, removeBlockedTag, addBlockedFolder, blockDocument, unblockDocument, getDocumentLevel, getAccessibleLevel, buildLeveledResult, setTagLevel, setFolderLevel, setNodeLevel, setDefaultLevel, createFullTextRequest, approveRequest, denyRequest, getPendingRequests, LEVEL_LABELS, LEVEL_ICONS, LEVEL_CREDIT_MULTIPLIER } from './federation/sharing.js';
+export { computeReputation, verifyConsensus, recordInteraction, recordConsistency, recordFeedback, recordConsensus, getReputationBoard, filterByReputation } from './federation/reputation.js';
+export { addDPNoise, addDPNoiseNormalized, maskSnippet } from './federation/privacy.js';
+export { getBalance, getAccount, earn, spend, earnForSearchResponse, spendForSearch, getRecentTransactions } from './federation/credits.js';
+// Plugin SDK
+export { PluginManager } from './plugins/index.js';
+export { WebhookManager } from './plugins/webhooks.js';
+export { loadCustomTools } from './mcp/custom-tools.js';
+// i18n
+export { t, setLocale, getLocale, detectLocale } from './i18n/index.js';
+// Error Recovery
+export { withRetry, StellavaultError, wrapError, errors } from './utils/retry.js';
+// Factory — 전체 조립
+import { createSqliteVecStore as _createStore } from './store/index.js';
+import { createLocalEmbedder as _createEmbedder } from './indexer/index.js';
+import { createSearchEngine as _createSearch } from './search/index.js';
+import { createMcpServer as _createMcp } from './mcp/index.js';
+export function createKnowledgeHub(config) {
+    const embedder = _createEmbedder(config.embedding.localModel);
+    const dims = embedder.dimensions;
+    const store = _createStore(config.dbPath, dims);
+    const searchEngine = _createSearch({ store, embedder, rrfK: config.search.rrfK });
+    const mcpServer = _createMcp({ store, searchEngine, vaultPath: config.vaultPath });
+    return { store, embedder, searchEngine, mcpServer, config };
+}
+//# sourceMappingURL=index.js.map

package/packages/core/dist/indexer/chunker.d.ts

@@ -0,0 +1,14 @@
+import type { Chunk } from '../types/chunk.js';
+export interface ChunkOptions {
+    maxTokens: number;
+    overlap: number;
+    minTokens: number;
+}
+/**
+ * 문서를 heading 기반으로 청킹합니다.
+ * Step 1: heading 분할 → Step 2: 길이 검사 → Step 3: 메타데이터 → Step 4: 짧은 청크 병합
+ */
+export declare function chunkDocument(documentId: string, content: string, options?: Partial<ChunkOptions>): Chunk[];
+/** 간단한 토큰 수 추정 (영어: ~4chars/token, 한국어: ~2chars/token) */
+export declare function estimateTokens(text: string): number;
+//# sourceMappingURL=chunker.d.ts.map

package/packages/core/dist/indexer/chunker.js

@@ -0,0 +1,148 @@
+// Design Ref: §6.1 — Chunking Strategy (heading 기반 + 오버랩)
+const DEFAULT_OPTIONS = {
+    maxTokens: 300,
+    overlap: 50,
+    minTokens: 50,
+};
+/**
+ * 문서를 heading 기반으로 청킹합니다.
+ * Step 1: heading 분할 → Step 2: 길이 검사 → Step 3: 메타데이터 → Step 4: 짧은 청크 병합
+ */
+export function chunkDocument(documentId, content, options = {}) {
+    const opts = { ...DEFAULT_OPTIONS, ...options };
+    const lines = content.split('\n');
+    // Step 1: heading 기반 섹션 분할
+    const sections = splitByHeadings(lines);
+    // Step 2-3: 길이 검사 + 메타데이터
+    const rawChunks = [];
+    for (const section of sections) {
+        const tokenCount = estimateTokens(section.content);
+        if (tokenCount <= opts.maxTokens) {
+            rawChunks.push(makeChunk(documentId, rawChunks.length, section));
+        }
+        else {
+            // 긴 섹션은 문장 단위로 재분할 + 오버랩
+            const subChunks = splitByTokenLimit(section, opts.maxTokens, opts.overlap);
+            for (const sub of subChunks) {
+                rawChunks.push(makeChunk(documentId, rawChunks.length, sub));
+            }
+        }
+    }
+    // Step 4: 짧은 청크 병합
+    return mergeShortChunks(rawChunks, opts.minTokens);
+}
+function splitByHeadings(lines) {
+    const sections = [];
+    let currentHeading = '';
+    let currentLines = [];
+    let startLine = 0;
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        if (/^#{1,6}\s/.test(line)) {
+            if (currentLines.length > 0) {
+                sections.push({
+                    heading: currentHeading,
+                    content: currentLines.join('\n').trim(),
+                    startLine,
+                    endLine: i - 1,
+                });
+            }
+            currentHeading = line.replace(/^#{1,6}\s+/, '').trim();
+            currentLines = [line];
+            startLine = i;
+        }
+        else {
+            currentLines.push(line);
+        }
+    }
+    if (currentLines.length > 0) {
+        sections.push({
+            heading: currentHeading,
+            content: currentLines.join('\n').trim(),
+            startLine,
+            endLine: lines.length - 1,
+        });
+    }
+    return sections.filter(s => s.content.length > 0);
+}
+function splitByTokenLimit(section, maxTokens, overlap) {
+    const sentences = section.content.split(/(?<=[.!?。]\s)/);
+    const results = [];
+    let current = [];
+    let currentTokens = 0;
+    for (const sentence of sentences) {
+        const sentenceTokens = estimateTokens(sentence);
+        if (currentTokens + sentenceTokens > maxTokens && current.length > 0) {
+            results.push({
+                heading: section.heading,
+                content: current.join('').trim(),
+                startLine: section.startLine,
+                endLine: section.endLine,
+            });
+            // 오버랩: 마지막 문장들을 다음 청크에 포함
+            const overlapText = getOverlapText(current, overlap);
+            current = overlapText ? [overlapText, sentence] : [sentence];
+            currentTokens = estimateTokens(current.join(''));
+        }
+        else {
+            current.push(sentence);
+            currentTokens += sentenceTokens;
+        }
+    }
+    if (current.length > 0) {
+        results.push({
+            heading: section.heading,
+            content: current.join('').trim(),
+            startLine: section.startLine,
+            endLine: section.endLine,
+        });
+    }
+    return results;
+}
+function getOverlapText(sentences, overlapTokens) {
+    let tokens = 0;
+    const overlap = [];
+    for (let i = sentences.length - 1; i >= 0; i--) {
+        const t = estimateTokens(sentences[i]);
+        if (tokens + t > overlapTokens)
+            break;
+        overlap.unshift(sentences[i]);
+        tokens += t;
+    }
+    return overlap.join('');
+}
+function mergeShortChunks(chunks, minTokens) {
+    if (chunks.length <= 1)
+        return chunks;
+    const result = [];
+    for (const chunk of chunks) {
+        if (result.length > 0 && chunk.tokenCount < minTokens) {
+            const prev = result[result.length - 1];
+            prev.content += '\n\n' + chunk.content;
+            prev.endLine = chunk.endLine;
+            prev.tokenCount += chunk.tokenCount;
+        }
+        else {
+            result.push({ ...chunk });
+        }
+    }
+    return result;
+}
+function makeChunk(documentId, index, section) {
+    return {
+        id: `${documentId}#${index}`,
+        documentId,
+        content: section.content,
+        heading: section.heading,
+        startLine: section.startLine,
+        endLine: section.endLine,
+        tokenCount: estimateTokens(section.content),
+    };
+}
+/** 간단한 토큰 수 추정 (영어: ~4chars/token, 한국어: ~2chars/token) */
+export function estimateTokens(text) {
+    const koreanChars = (text.match(/[가-힣]/g) || []).length;
+    const otherChars = text.length - koreanChars;
+    return Math.ceil(koreanChars / 2 + otherChars / 4);
+}
+//# sourceMappingURL=chunker.js.map

package/packages/core/dist/indexer/embedder.d.ts

@@ -0,0 +1,8 @@
+export interface Embedder {
+    initialize(): Promise<void>;
+    embed(text: string): Promise<number[]>;
+    embedBatch(texts: string[]): Promise<number[][]>;
+    readonly dimensions: number;
+    readonly modelName: string;
+}
+//# sourceMappingURL=embedder.d.ts.map

package/packages/core/dist/indexer/embedder.js

@@ -0,0 +1,3 @@
+// Design Ref: §3.2 — 교체 가능 설계 (Embedder 인터페이스)
+export {};
+//# sourceMappingURL=embedder.js.map

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

@@ -0,0 +1,28 @@
+import type { Embedder } from './embedder.js';
+import type { VectorStore } from '../store/types.js';
+import type { Document } from '../types/document.js';
+import { type ChunkOptions } from './chunker.js';
+export { type Embedder } from './embedder.js';
+export { createLocalEmbedder } from './local-embedder.js';
+export { scanVault } from './scanner.js';
+export { chunkDocument, estimateTokens } from './chunker.js';
+export { createWatcher } from './watcher.js';
+export interface IndexerOptions {
+    store: VectorStore;
+    embedder: Embedder;
+    chunkOptions?: Partial<ChunkOptions>;
+    onProgress?: (current: number, total: number, doc: Document) => void;
+}
+export interface IndexResult {
+    indexed: number;
+    skipped: number;
+    deleted: number;
+    failed: number;
+    totalChunks: number;
+    elapsedMs: number;
+}
+/**
+ * vault를 스캔하여 변경된 문서만 벡터화하는 증분 인덱서
+ */
+export declare function indexVault(vaultPath: string, options: IndexerOptions): Promise<IndexResult>;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,74 @@
+// Design Ref: §6.3 — Incremental Indexing + Pipeline
+import { scanVault } from './scanner.js';
+import { chunkDocument } from './chunker.js';
+import { withRetry, errors } from '../utils/retry.js';
+export { createLocalEmbedder } from './local-embedder.js';
+export { scanVault } from './scanner.js';
+export { chunkDocument, estimateTokens } from './chunker.js';
+export { createWatcher } from './watcher.js';
+/**
+ * vault를 스캔하여 변경된 문서만 벡터화하는 증분 인덱서
+ */
+export async function indexVault(vaultPath, options) {
+    const start = Date.now();
+    const { store, embedder, chunkOptions, onProgress } = options;
+    // 1. 스캔
+    const { documents } = scanVault(vaultPath);
+    // 2. 기존 인덱스 상태 조회
+    const existingDocs = await store.getAllDocuments();
+    const existingMap = new Map(existingDocs.map(d => [d.id, d.contentHash]));
+    let indexed = 0;
+    let skipped = 0;
+    let failed = 0;
+    let totalChunks = 0;
+    // 3. 증분 처리 (에러 복구 포함)
+    const scannedIds = new Set();
+    for (let i = 0; i < documents.length; i++) {
+        const doc = documents[i];
+        scannedIds.add(doc.id);
+        onProgress?.(i + 1, documents.length, doc);
+        // content_hash 비교 → 변경 없으면 SKIP
+        if (existingMap.get(doc.id) === doc.contentHash) {
+            skipped++;
+            continue;
+        }
+        try {
+            // 청킹
+            const chunks = chunkDocument(doc.id, doc.content, chunkOptions);
+            // 임베딩 (retry with backoff)
+            const texts = chunks.map(c => c.content);
+            const embeddings = await withRetry(() => embedder.embedBatch(texts), { maxRetries: 2, baseDelayMs: 1000 });
+            const chunksWithEmbeddings = chunks.map((c, j) => ({
+                ...c,
+                embedding: embeddings[j],
+            }));
+            // 저장 (document → chunks)
+            await store.upsertDocument(doc);
+            await store.upsertChunks(chunksWithEmbeddings);
+            indexed++;
+            totalChunks += chunks.length;
+        }
+        catch (err) {
+            // Graceful degradation: skip failed file, continue with rest
+            failed++;
+            console.error(errors.indexingFailed(doc.filePath, err).format());
+        }
+    }
+    // 4. 삭제된 파일 처리
+    let deleted = 0;
+    for (const [existingId] of existingMap) {
+        if (!scannedIds.has(existingId)) {
+            await store.deleteByDocumentId(existingId);
+            deleted++;
+        }
+    }
+    return {
+        indexed,
+        skipped,
+        deleted,
+        failed,
+        totalChunks,
+        elapsedMs: Date.now() - start,
+    };
+}
+//# sourceMappingURL=index.js.map

package/packages/core/dist/indexer/local-embedder.d.ts

@@ -0,0 +1,3 @@
+import type { Embedder } from './embedder.js';
+export declare function createLocalEmbedder(modelName?: string): Embedder;
+//# sourceMappingURL=local-embedder.d.ts.map

package/packages/core/dist/indexer/local-embedder.js

@@ -0,0 +1,29 @@
+// Design Ref: §3.2 — Embedder 로컬 구현 (nomic-embed-text via @xenova/transformers)
+export function createLocalEmbedder(modelName = 'nomic-embed-text-v1.5') {
+    let pipeline;
+    // all-MiniLM-L6-v2: 384, nomic-embed-text: 768
+    let dims = modelName.includes('MiniLM') ? 384 : 768;
+    return {
+        async initialize() {
+            const { pipeline: createPipeline } = await import('@xenova/transformers');
+            pipeline = await createPipeline('feature-extraction', `Xenova/${modelName}`, {
+                quantized: true,
+            });
+        },
+        async embed(text) {
+            const output = await pipeline(text, { pooling: 'mean', normalize: true });
+            return Array.from(output.data).slice(0, dims);
+        },
+        async embedBatch(texts) {
+            const results = [];
+            // 순차 처리 (메모리 절약)
+            for (const text of texts) {
+                results.push(await this.embed(text));
+            }
+            return results;
+        },
+        get dimensions() { return dims; },
+        get modelName() { return modelName; },
+    };
+}
+//# sourceMappingURL=local-embedder.js.map

package/packages/core/dist/indexer/scanner.d.ts

@@ -0,0 +1,11 @@
+import type { Document } from '../types/document.js';
+export interface ScanResult {
+    documents: Document[];
+    scannedFiles: number;
+    skippedFiles: number;
+}
+/**
+ * vault 디렉토리에서 모든 .md 파일을 스캔하여 Document 목록 반환
+ */
+export declare function scanVault(vaultPath: string): ScanResult;
+//# sourceMappingURL=scanner.d.ts.map

package/packages/core/dist/indexer/scanner.js

@@ -0,0 +1,137 @@
+// Design Ref: §6 — Indexer (scanner: glob + frontmatter 파싱)
+import { readdirSync, readFileSync, statSync } from 'node:fs';
+import { join, relative, extname } from 'node:path';
+import { createHash } from 'node:crypto';
+import matter from 'gray-matter';
+/**
+ * vault 디렉토리에서 모든 .md 파일을 스캔하여 Document 목록 반환
+ */
+export function scanVault(vaultPath) {
+    const documents = [];
+    let skippedFiles = 0;
+    const mdFiles = findMdFiles(vaultPath);
+    for (const filePath of mdFiles) {
+        try {
+            const doc = parseDocument(vaultPath, filePath);
+            documents.push(doc);
+        }
+        catch {
+            skippedFiles++;
+        }
+    }
+    return { documents, scannedFiles: mdFiles.length, skippedFiles };
+}
+function findMdFiles(dir, files = []) {
+    for (const entry of readdirSync(dir, { withFileTypes: true })) {
+        const fullPath = join(dir, entry.name);
+        if (entry.isDirectory()) {
+            if (entry.name.startsWith('.') || entry.name === 'node_modules' || entry.name === 'zh-CN')
+                continue;
+            findMdFiles(fullPath, files);
+        }
+        else if (extname(entry.name) === '.md') {
+            files.push(fullPath);
+        }
+    }
+    return files;
+}
+function parseDocument(vaultPath, filePath) {
+    const raw = readFileSync(filePath, 'utf-8');
+    const stat = statSync(filePath);
+    const { data: frontmatter, content } = matter(raw);
+    const relativePath = relative(vaultPath, filePath).replace(/\\/g, '/');
+    const id = createHash('sha256').update(relativePath).digest('hex').slice(0, 16);
+    const contentHash = createHash('sha256').update(raw).digest('hex').slice(0, 16);
+    const title = frontmatter.title
+        ?? extractFirstHeading(content)
+        ?? relativePath.replace(/\.md$/, '');
+    const tags = extractTags(frontmatter, content);
+    // source/type 자동 추출 (원본 파일 수정 없이 DB에만 저장)
+    const source = inferSource(frontmatter, relativePath);
+    const type = inferType(frontmatter, relativePath);
+    return {
+        id,
+        filePath: relativePath,
+        title,
+        content,
+        frontmatter,
+        tags,
+        lastModified: stat.mtime.toISOString(),
+        contentHash,
+        source,
+        type,
+    };
+}
+function inferSource(frontmatter, filePath) {
+    // frontmatter에 명시된 경우
+    if (frontmatter.source && typeof frontmatter.source === 'string') {
+        if (frontmatter.source.startsWith('http'))
+            return 'clip';
+        return frontmatter.source;
+    }
+    // 경로 기반 추론
+    if (filePath.includes('clips/') || filePath.includes('clip/'))
+        return 'clip';
+    if (filePath.includes('PDCA') || filePath.includes('pdca'))
+        return 'local';
+    if (frontmatter['x-i18n'])
+        return 'notion'; // Notion 번역 문서
+    if (frontmatter.clipped)
+        return 'clip';
+    return 'local';
+}
+function inferType(frontmatter, filePath) {
+    // frontmatter에 명시된 경우
+    if (frontmatter.type && typeof frontmatter.type === 'string')
+        return frontmatter.type;
+    // tags 기반
+    const tags = Array.isArray(frontmatter.tags) ? frontmatter.tags : [];
+    if (tags.includes('bridge') || tags.includes('auto-generated'))
+        return 'bridge';
+    if (tags.includes('clip') || tags.includes('youtube'))
+        return 'clip';
+    if (tags.includes('decision'))
+        return 'decision';
+    // 경로 기반
+    if (filePath.includes('clips/'))
+        return 'clip';
+    if (filePath.includes('Decisions/') || filePath.includes('decisions/'))
+        return 'decision';
+    if (filePath.includes('Sessions/') || filePath.includes('sessions/'))
+        return 'session';
+    if (filePath.includes('Research/'))
+        return 'research';
+    if (filePath.includes('Lessons/'))
+        return 'lesson';
+    if (filePath.includes('Templates/'))
+        return 'template';
+    return 'note';
+}
+function extractFirstHeading(content) {
+    const match = content.match(/^#\s+(.+)$/m);
+    return match ? match[1].trim() : null;
+}
+function extractTags(frontmatter, content) {
+    const tags = new Set();
+    // frontmatter tags
+    const fmTags = frontmatter.tags;
+    if (Array.isArray(fmTags)) {
+        fmTags.forEach(t => tags.add(String(t)));
+    }
+    else if (typeof fmTags === 'string') {
+        fmTags.split(',').map(t => t.trim()).filter(Boolean).forEach(t => tags.add(t));
+    }
+    // inline #tags (CSS 컬러코드, 순수 숫자, heading # 제외)
+    const inlineTags = content.match(/(?:^|\s)#([a-zA-Z가-힣][a-zA-Z가-힣\w-]*)/g);
+    if (inlineTags) {
+        for (const raw of inlineTags) {
+            const tag = raw.trim().slice(1);
+            // CSS hex 컬러 (#fff, #6c5ce7 등) 제외
+            if (/^[0-9a-fA-F]{3,8}$/.test(tag))
+                continue;
+            tags.add(tag);
+        }
+    }
+    return [...tags];
+}
+//# sourceMappingURL=scanner.js.map

package/packages/core/dist/indexer/watcher.d.ts

@@ -0,0 +1,19 @@
+import type { Embedder } from './embedder.js';
+import type { VectorStore } from '../store/types.js';
+import type { ChunkOptions } from './chunker.js';
+export interface WatcherOptions {
+    vaultPath: string;
+    store: VectorStore;
+    embedder: Embedder;
+    chunkOptions?: Partial<ChunkOptions>;
+    debounceMs?: number;
+    onReindex?: (result: {
+        indexed: number;
+        skipped: number;
+    }) => void;
+}
+export declare function createWatcher(options: WatcherOptions): {
+    start(): void;
+    stop(): void;
+};
+//# sourceMappingURL=watcher.d.ts.map

package/packages/core/dist/indexer/watcher.js

@@ -0,0 +1,49 @@
+// Design Ref: §6.3 — 파일 감시 + 증분 인덱싱 (debounce 5s)
+import { watch } from 'chokidar';
+import { extname } from 'node:path';
+import { indexVault } from './index.js';
+export function createWatcher(options) {
+    const { vaultPath, store, embedder, chunkOptions, debounceMs = 5000, onReindex } = options;
+    let watcher = null;
+    let debounceTimer = null;
+    let reindexing = false;
+    async function triggerReindex() {
+        if (reindexing)
+            return;
+        reindexing = true;
+        try {
+            const result = await indexVault(vaultPath, { store, embedder, chunkOptions });
+            onReindex?.({ indexed: result.indexed, skipped: result.skipped });
+        }
+        finally {
+            reindexing = false;
+        }
+    }
+    function scheduleReindex() {
+        if (debounceTimer)
+            clearTimeout(debounceTimer);
+        debounceTimer = setTimeout(() => triggerReindex(), debounceMs);
+    }
+    return {
+        start() {
+            watcher = watch(vaultPath, {
+                ignored: /(^|[\/\\])\.|node_modules/,
+                persistent: true,
+                ignoreInitial: true,
+            });
+            watcher.on('all', (event, path) => {
+                if (extname(path) !== '.md')
+                    return;
+                if (['add', 'change', 'unlink'].includes(event)) {
+                    scheduleReindex();
+                }
+            });
+        },
+        stop() {
+            if (debounceTimer)
+                clearTimeout(debounceTimer);
+            watcher?.close();
+        },
+    };
+}
+//# sourceMappingURL=watcher.js.map

package/packages/core/dist/intelligence/contradiction-detector.d.ts

@@ -0,0 +1,20 @@
+import type { VectorStore } from '../store/types.js';
+export interface ContradictionPair {
+    docA: {
+        id: string;
+        title: string;
+        filePath: string;
+        statement: string;
+    };
+    docB: {
+        id: string;
+        title: string;
+        filePath: string;
+        statement: string;
+    };
+    similarity: number;
+    confidence: number;
+    type: 'negation' | 'value_conflict' | 'temporal' | 'semantic';
+}
+export declare function detectContradictions(store: VectorStore, limit?: number): Promise<ContradictionPair[]>;
+//# sourceMappingURL=contradiction-detector.d.ts.map