stellavault 0.4.4 → 0.5.0

package/packages/core/dist/intelligence/duplicate-detector.js

@@ -1,55 +0,0 @@
-// Design Ref: 중복/유사 노트 탐지
-// 기존 벡터 임베딩의 cosine similarity 활용
-/**
- * 벡터 유사도 기반 중복 노트 탐지.
- * 문서별 평균 임베딩을 비교하여 threshold 이상인 쌍을 반환.
- */
-export async function detectDuplicates(store, threshold = 0.88, limit = 20) {
-    const docs = await store.getAllDocuments();
-    const embeddings = await store.getDocumentEmbeddings();
-    if (docs.length < 2)
-        return [];
-    // 문서별 평균 임베딩 계산
-    const docVecs = new Map();
-    for (const doc of docs) {
-        const vec = embeddings.get(doc.id);
-        if (!vec || vec.length === 0)
-            continue;
-        docVecs.set(doc.id, { vec: Array.from(vec), title: doc.title, filePath: doc.filePath });
-    }
-    const ids = [...docVecs.keys()];
-    const pairs = [];
-    // O(n²) — 1,200 문서면 ~720K 비교, 수 초 이내
-    for (let i = 0; i < ids.length; i++) {
-        for (let j = i + 1; j < ids.length; j++) {
-            const a = docVecs.get(ids[i]);
-            const b = docVecs.get(ids[j]);
-            const sim = cosineSimilarity(a.vec, b.vec);
-            if (sim >= threshold) {
-                pairs.push({
-                    docA: { id: ids[i], title: a.title, filePath: a.filePath },
-                    docB: { id: ids[j], title: b.title, filePath: b.filePath },
-                    similarity: Math.round(sim * 1000) / 1000,
-                });
-            }
-        }
-        if (pairs.length >= limit * 2)
-            break; // 충분히 찾으면 중단
-    }
-    return pairs
-        .sort((a, b) => b.similarity - a.similarity)
-        .slice(0, limit);
-}
-function cosineSimilarity(a, b) {
-    if (a.length !== b.length)
-        return 0;
-    let dot = 0, normA = 0, normB = 0;
-    for (let i = 0; i < a.length; i++) {
-        dot += a[i] * b[i];
-        normA += a[i] * a[i];
-        normB += b[i] * b[i];
-    }
-    const denom = Math.sqrt(normA) * Math.sqrt(normB);
-    return denom === 0 ? 0 : dot / denom;
-}
-//# sourceMappingURL=duplicate-detector.js.map

package/packages/core/dist/intelligence/file-extractors.d.ts

@@ -1,13 +0,0 @@
-export interface ExtractedContent {
-    text: string;
-    metadata: {
-        title?: string;
-        author?: string;
-        pageCount?: number;
-        wordCount: number;
-    };
-    sourceFormat: 'pdf' | 'docx' | 'pptx' | 'xlsx' | 'xls' | 'text';
-}
-export declare function isBinaryFormat(filePath: string): boolean;
-export declare function extractFileContent(filePath: string): Promise<ExtractedContent>;
-//# sourceMappingURL=file-extractors.d.ts.map

package/packages/core/dist/intelligence/file-extractors.js

@@ -1,155 +0,0 @@
-// Design Ref: §file-ingest-v2 — Binary file text extraction dispatchers
-// Plan SC: SC1-SC5 (format-specific extraction + fallback)
-import { readFileSync, statSync } from 'node:fs';
-import { extname, basename } from 'node:path';
-const BINARY_EXTS = new Set(['.pdf', '.docx', '.pptx', '.xlsx', '.xls']);
-export function isBinaryFormat(filePath) {
-    return BINARY_EXTS.has(extname(filePath).toLowerCase());
-}
-/**
- * 파일 경로에서 텍스트 추출. 확장자 기반 파서 디스패치.
- * 지원: .pdf, .docx, .pptx, .xlsx, .xls
- * 미지원 확장자: utf-8 텍스트로 읽기
- */
-const MAX_FILE_SIZE = 50 * 1024 * 1024; // 50MB
-export async function extractFileContent(filePath) {
-    const ext = extname(filePath).toLowerCase();
-    const { size } = statSync(filePath);
-    if (size > MAX_FILE_SIZE) {
-        throw new Error(`File too large (${Math.round(size / 1024 / 1024)}MB > 50MB limit)`);
-    }
-    const buffer = readFileSync(filePath);
-    switch (ext) {
-        case '.pdf': return extractPdf(buffer, filePath);
-        case '.docx': return extractDocx(buffer, filePath);
-        case '.pptx': return extractPptx(buffer, filePath);
-        case '.xlsx': return extractXlsx(buffer, filePath);
-        case '.xls': return extractXlsx(buffer, filePath);
-        default: return extractText(filePath);
-    }
-}
-async function extractPdf(buffer, filePath) {
-    try {
-        const { extractText } = await import('unpdf');
-        const result = await extractText(new Uint8Array(buffer));
-        const text = Array.isArray(result.text) ? result.text.join('\n\n') : (result.text ?? '');
-        return {
-            text,
-            metadata: {
-                title: basename(filePath, '.pdf'),
-                pageCount: result.totalPages,
-                wordCount: text.split(/\s+/).filter(Boolean).length,
-            },
-            sourceFormat: 'pdf',
-        };
-    }
-    catch (err) {
-        console.error(`PDF extraction failed: ${err instanceof Error ? err.message : 'unknown'}`);
-        return fallback(filePath, 'pdf');
-    }
-}
-async function extractDocx(buffer, filePath) {
-    try {
-        const mammoth = await import('mammoth');
-        const result = await mammoth.default.extractRawText({ buffer });
-        const text = result.value ?? '';
-        return {
-            text,
-            metadata: {
-                title: basename(filePath, '.docx'),
-                wordCount: text.split(/\s+/).filter(Boolean).length,
-            },
-            sourceFormat: 'docx',
-        };
-    }
-    catch (err) {
-        console.error(`DOCX extraction failed: ${err instanceof Error ? err.message : 'unknown'}`);
-        return fallback(filePath, 'docx');
-    }
-}
-async function extractPptx(buffer, filePath) {
-    try {
-        const officeparser = await import('officeparser');
-        const text = String(await officeparser.default.parseOffice(buffer));
-        return {
-            text: text ?? '',
-            metadata: {
-                title: basename(filePath, '.pptx'),
-                wordCount: (text ?? '').split(/\s+/).filter(Boolean).length,
-            },
-            sourceFormat: 'pptx',
-        };
-    }
-    catch (err) {
-        console.error(`PPTX extraction failed: ${err instanceof Error ? err.message : 'unknown'}`);
-        return fallback(filePath, 'pptx');
-    }
-}
-async function extractXlsx(buffer, filePath) {
-    const ext = extname(filePath).toLowerCase();
-    const format = ext === '.xls' ? 'xls' : 'xlsx';
-    try {
-        const XLSX = await import('xlsx');
-        const workbook = XLSX.read(buffer);
-        const parts = [];
-        for (const name of workbook.SheetNames) {
-            const sheet = workbook.Sheets[name];
-            // 마크다운 테이블 형식 (헤더-값 구조 보존)
-            const rows = XLSX.utils.sheet_to_json(sheet, { header: 1 });
-            if (rows.length === 0)
-                continue;
-            parts.push(`## ${name}\n`);
-            const headers = rows[0].map((h) => String(h ?? ''));
-            parts.push(`| ${headers.join(' | ')} |`);
-            parts.push(`| ${headers.map(() => '---').join(' | ')} |`);
-            for (const row of rows.slice(1)) {
-                const cells = headers.map((_, i) => String(row[i] ?? ''));
-                parts.push(`| ${cells.join(' | ')} |`);
-            }
-            parts.push('');
-            // JSON 구조도 포함 (AI 검색/ask에서 수치 활용 가능)
-            if (rows.length <= 100) {
-                const jsonRows = XLSX.utils.sheet_to_json(sheet);
-                if (jsonRows.length > 0) {
-                    parts.push(`<details><summary>Structured Data (${jsonRows.length} rows)</summary>\n`);
-                    parts.push('```json');
-                    parts.push(JSON.stringify(jsonRows.slice(0, 50), null, 2));
-                    parts.push('```');
-                    parts.push('</details>\n');
-                }
-            }
-        }
-        const text = parts.join('\n');
-        return {
-            text,
-            metadata: {
-                title: basename(filePath, ext),
-                wordCount: text.split(/\s+/).filter(Boolean).length,
-            },
-            sourceFormat: format,
-        };
-    }
-    catch (err) {
-        console.error(`XLSX extraction failed: ${err instanceof Error ? err.message : 'unknown'}`);
-        return fallback(filePath, format);
-    }
-}
-function extractText(filePath) {
-    const text = readFileSync(filePath, 'utf-8');
-    return {
-        text,
-        metadata: {
-            title: basename(filePath),
-            wordCount: text.split(/\s+/).filter(Boolean).length,
-        },
-        sourceFormat: 'text',
-    };
-}
-function fallback(filePath, format) {
-    return {
-        text: `[Failed to extract text from ${basename(filePath)}. Install required parser or convert to a text format.]`,
-        metadata: { title: basename(filePath), wordCount: 0 },
-        sourceFormat: format,
-    };
-}
-//# sourceMappingURL=file-extractors.js.map

package/packages/core/dist/intelligence/fsrs.d.ts

@@ -1,43 +0,0 @@
-/**
- * FSRS parameters tuned for knowledge notes (not flashcards).
- * Knowledge notes have longer natural retention than flashcards.
- */
-export declare const FSRS_PARAMS: {
-    readonly initialStability: 7;
-    readonly difficulty: 5;
-    readonly a: 0.4;
-    readonly b: 0.6;
-    readonly c: 0.2;
-    readonly d: 1;
-    readonly sizeFactor: 0.5;
-    readonly connectionFactor: 1;
-};
-/**
- * Compute retrievability R(t) using FSRS power forgetting curve.
- * R(t) = (1 + t / (9 * S))^(-1)
- *
- * @param stabilityDays - Stability S (days until R drops to ~0.9)
- * @param elapsedDays - Days since last access
- * @returns Retrievability 0~1
- */
-export declare function computeRetrievability(stabilityDays: number, elapsedDays: number): number;
-/**
- * Update stability after an access event (successful recall).
- * S' = S * (1 + a * D^(-b) * S^(-c) * (e^(d*(1-R)) - 1))
- *
- * @param currentS - Current stability
- * @param difficulty - Note difficulty (1~10)
- * @param currentR - Retrievability at access time
- * @returns New stability (always >= currentS)
- */
-export declare function updateStability(currentS: number, difficulty: number, currentR: number): number;
-/**
- * Estimate initial stability based on note characteristics.
- * Longer notes and more connected notes are more stable.
- */
-export declare function estimateInitialStability(contentLength: number, connectionCount: number): number;
-/**
- * Compute elapsed days between two ISO timestamps.
- */
-export declare function elapsedDays(from: string, to?: string): number;
-//# sourceMappingURL=fsrs.d.ts.map

package/packages/core/dist/intelligence/fsrs.js

@@ -1,70 +0,0 @@
-// Design Ref: §1 — FSRS-6 알고리즘 (순수 함수)
-// Plan SC: SC-01 (R값 계산), SC-02 (stability 업데이트)
-/**
- * FSRS parameters tuned for knowledge notes (not flashcards).
- * Knowledge notes have longer natural retention than flashcards.
- */
-export const FSRS_PARAMS = {
-    initialStability: 7.0, // 7 days for new notes
-    difficulty: 5.0, // default difficulty (1~10)
-    // Stability growth factors
-    a: 0.4,
-    b: 0.6,
-    c: 0.2,
-    d: 1.0,
-    // Stability bonus for large/connected notes
-    sizeFactor: 0.5, // additional days per 1000 chars
-    connectionFactor: 1.0, // additional days per connection
-};
-/**
- * Compute retrievability R(t) using FSRS power forgetting curve.
- * R(t) = (1 + t / (9 * S))^(-1)
- *
- * @param stabilityDays - Stability S (days until R drops to ~0.9)
- * @param elapsedDays - Days since last access
- * @returns Retrievability 0~1
- */
-export function computeRetrievability(stabilityDays, elapsedDays) {
-    if (elapsedDays <= 0)
-        return 1.0;
-    if (stabilityDays <= 0)
-        return 0.0;
-    return Math.pow(1 + elapsedDays / (9 * stabilityDays), -1);
-}
-/**
- * Update stability after an access event (successful recall).
- * S' = S * (1 + a * D^(-b) * S^(-c) * (e^(d*(1-R)) - 1))
- *
- * @param currentS - Current stability
- * @param difficulty - Note difficulty (1~10)
- * @param currentR - Retrievability at access time
- * @returns New stability (always >= currentS)
- */
-export function updateStability(currentS, difficulty, currentR) {
-    const { a, b, c, d } = FSRS_PARAMS;
-    const growth = a
-        * Math.pow(difficulty, -b)
-        * Math.pow(currentS, -c)
-        * (Math.exp(d * (1 - currentR)) - 1);
-    const newS = currentS * (1 + Math.max(0, growth));
-    // Cap at 365 days (1 year max stability)
-    return Math.min(newS, 365);
-}
-/**
- * Estimate initial stability based on note characteristics.
- * Longer notes and more connected notes are more stable.
- */
-export function estimateInitialStability(contentLength, connectionCount) {
-    const base = FSRS_PARAMS.initialStability;
-    const sizeBonus = Math.min(contentLength / 1000, 10) * FSRS_PARAMS.sizeFactor;
-    const connBonus = Math.min(connectionCount, 10) * FSRS_PARAMS.connectionFactor;
-    return base + sizeBonus + connBonus;
-}
-/**
- * Compute elapsed days between two ISO timestamps.
- */
-export function elapsedDays(from, to = new Date().toISOString()) {
-    const msPerDay = 86400000;
-    return Math.max(0, (new Date(to).getTime() - new Date(from).getTime()) / msPerDay);
-}
-//# sourceMappingURL=fsrs.js.map

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

@@ -1,25 +0,0 @@
-import type { VectorStore } from '../store/types.js';
-export interface KnowledgeGap {
-    clusterA: string;
-    clusterB: string;
-    bridgeCount: number;
-    suggestedTopic: string;
-    severity: 'high' | 'medium' | 'low';
-}
-export interface GapReport {
-    totalClusters: number;
-    totalGaps: number;
-    gaps: KnowledgeGap[];
-    isolatedNodes: Array<{
-        id: string;
-        title: string;
-        connections: number;
-    }>;
-}
-/**
- * 그래프 데이터에서 지식 갭을 탐지.
- * - 클러스터 간 연결이 약한 영역
- * - 고립된 노드 (연결 0~1개)
- */
-export declare function detectKnowledgeGaps(store: VectorStore, graphData?: any): Promise<GapReport>;
-//# sourceMappingURL=gap-detector.d.ts.map

package/packages/core/dist/intelligence/gap-detector.js

@@ -1,78 +0,0 @@
-// Design Ref: F01 — 지식 갭 탐지기
-// 클러스터 간 브릿지 노드 부족 영역 식별
-/**
- * 그래프 데이터에서 지식 갭을 탐지.
- * - 클러스터 간 연결이 약한 영역
- * - 고립된 노드 (연결 0~1개)
- */
-export async function detectKnowledgeGaps(store, graphData) {
-    const docs = await store.getAllDocuments();
-    const embeddings = await store.getDocumentEmbeddings();
-    // 그래프 데이터가 없으면 간단히 계산
-    if (!graphData) {
-        const { buildGraphData } = await import('../api/graph-data.js');
-        graphData = await buildGraphData(store);
-    }
-    const { nodes, edges, clusters } = graphData;
-    // 1. 클러스터 간 연결 수 매트릭스
-    const clusterEdges = new Map();
-    for (const edge of edges) {
-        const nodeA = nodes.find((n) => n.id === edge.source);
-        const nodeB = nodes.find((n) => n.id === edge.target);
-        if (!nodeA || !nodeB || nodeA.clusterId === nodeB.clusterId)
-            continue;
-        const key = [
-            Math.min(nodeA.clusterId, nodeB.clusterId),
-            Math.max(nodeA.clusterId, nodeB.clusterId),
-        ].join('-');
-        clusterEdges.set(key, (clusterEdges.get(key) ?? 0) + 1);
-    }
-    // 2. 갭 식별 (클러스터 쌍 중 연결이 적은 것)
-    const gaps = [];
-    const clusterLabels = new Map(clusters.map((c) => [c.id, c.label]));
-    for (let i = 0; i < clusters.length; i++) {
-        for (let j = i + 1; j < clusters.length; j++) {
-            const key = `${Math.min(clusters[i].id, clusters[j].id)}-${Math.max(clusters[i].id, clusters[j].id)}`;
-            const bridgeCount = clusterEdges.get(key) ?? 0;
-            // 연결이 3개 미만이면 갭
-            if (bridgeCount < 3) {
-                const labelA = clusterLabels.get(clusters[i].id) ?? `Cluster ${clusters[i].id}`;
-                const labelB = clusterLabels.get(clusters[j].id) ?? `Cluster ${clusters[j].id}`;
-                // 제안 주제: 두 클러스터 이름에서 추출
-                const nameA = labelA.replace(/\s*\(\d+\)$/, '');
-                const nameB = labelB.replace(/\s*\(\d+\)$/, '');
-                gaps.push({
-                    clusterA: labelA,
-                    clusterB: labelB,
-                    bridgeCount,
-                    suggestedTopic: `${nameA} + ${nameB} 연결 지식`,
-                    severity: bridgeCount === 0 ? 'high' : bridgeCount < 2 ? 'medium' : 'low',
-                });
-            }
-        }
-    }
-    // 3. 고립 노드 (연결 1개 이하)
-    const connectionCounts = new Map();
-    for (const edge of edges) {
-        connectionCounts.set(edge.source, (connectionCounts.get(edge.source) ?? 0) + 1);
-        connectionCounts.set(edge.target, (connectionCounts.get(edge.target) ?? 0) + 1);
-    }
-    const isolatedNodes = nodes
-        .filter((n) => (connectionCounts.get(n.id) ?? 0) <= 1)
-        .map((n) => ({
-        id: n.id,
-        title: n.label,
-        connections: connectionCounts.get(n.id) ?? 0,
-    }))
-        .slice(0, 20);
-    return {
-        totalClusters: clusters.length,
-        totalGaps: gaps.filter(g => g.severity !== 'low').length,
-        gaps: gaps.sort((a, b) => {
-            const sev = { high: 0, medium: 1, low: 2 };
-            return sev[a.severity] - sev[b.severity];
-        }).slice(0, 15),
-        isolatedNodes,
-    };
-}
-//# sourceMappingURL=gap-detector.js.map

package/packages/core/dist/intelligence/ingest-pipeline.d.ts

@@ -1,32 +0,0 @@
-import { type FolderNames } from '../config.js';
-export type NoteStage = 'fleeting' | 'literature' | 'permanent';
-export interface IngestInput {
-    type: 'url' | 'text' | 'file' | 'youtube' | 'pdf-text' | 'pdf' | 'docx' | 'pptx' | 'xlsx' | 'xls';
-    content: string;
-    title?: string;
-    tags?: string[];
-    source?: string;
-    stage?: NoteStage;
-}
-export interface IngestResult {
-    savedTo: string;
-    stage: NoteStage;
-    title: string;
-    indexCode?: string;
-    tags: string[];
-    wordCount: number;
-}
-/**
- * 어떤 입력이든 Stellavault 표준 포맷으로 변환하여 저장.
- */
-export declare function ingest(vaultPath: string, input: IngestInput, folders?: FolderNames): IngestResult;
-/**
- * 여러 입력을 배치 처리.
- */
-export declare function ingestBatch(vaultPath: string, inputs: IngestInput[]): IngestResult[];
-/**
- * 노트 승격: fleeting → literature → permanent.
- * 내용이 충분히 정제되면 다음 단계로 이동.
- */
-export declare function promoteNote(vaultPath: string, filePath: string, targetStage: NoteStage, folders?: FolderNames): string;
-//# sourceMappingURL=ingest-pipeline.d.ts.map