stellavault 0.3.0 → 0.4.1

package/packages/core/dist/intelligence/knowledge-lint.d.ts

@@ -0,0 +1,27 @@
+import type { VectorStore } from '../store/types.js';
+export interface LintResult {
+    score: number;
+    issues: LintIssue[];
+    suggestions: string[];
+    stats: {
+        totalDocs: number;
+        gaps: number;
+        duplicates: number;
+        contradictions: number;
+        isolatedNodes: number;
+        orphanTags: number;
+    };
+}
+export interface LintIssue {
+    type: 'gap' | 'duplicate' | 'contradiction' | 'isolated' | 'stale' | 'empty';
+    severity: 'critical' | 'warning' | 'info';
+    message: string;
+    filePath?: string;
+    suggestion?: string;
+}
+/**
+ * vault 전체를 스캔하여 지식 건강도를 평가.
+ * 기존 gap-detector, duplicate-detector, contradiction-detector를 통합.
+ */
+export declare function lintKnowledge(store: VectorStore): Promise<LintResult>;
+//# sourceMappingURL=knowledge-lint.d.ts.map

package/packages/core/dist/intelligence/knowledge-lint.js

@@ -0,0 +1,132 @@
+// Feature: stellavault lint — 자동 지식 건강 검사
+// 불일치, 누락, 연결 제안, 고립 노드 등을 종합 리포트
+import { detectKnowledgeGaps } from './gap-detector.js';
+import { detectDuplicates } from './duplicate-detector.js';
+import { detectContradictions } from './contradiction-detector.js';
+/**
+ * vault 전체를 스캔하여 지식 건강도를 평가.
+ * 기존 gap-detector, duplicate-detector, contradiction-detector를 통합.
+ */
+export async function lintKnowledge(store) {
+    const issues = [];
+    const suggestions = [];
+    const docs = await store.getAllDocuments();
+    const totalDocs = docs.length;
+    // 1. 갭 탐지
+    let gapCount = 0;
+    let isolatedCount = 0;
+    try {
+        const gapReport = await detectKnowledgeGaps(store);
+        gapCount = gapReport.totalGaps;
+        isolatedCount = gapReport.isolatedNodes.length;
+        for (const gap of gapReport.gaps.filter(g => g.severity !== 'low')) {
+            issues.push({
+                type: 'gap',
+                severity: gap.severity === 'high' ? 'critical' : 'warning',
+                message: `Knowledge gap: ${gap.clusterA} ↔ ${gap.clusterB} (${gap.bridgeCount} connections)`,
+                suggestion: gap.suggestedTopic,
+            });
+        }
+        for (const node of gapReport.isolatedNodes.slice(0, 10)) {
+            issues.push({
+                type: 'isolated',
+                severity: 'warning',
+                message: `Isolated note: "${node.title}" (${node.connections} connections)`,
+                filePath: node.id,
+                suggestion: 'Add links to related topics or tags to integrate this note.',
+            });
+        }
+    }
+    catch (err) {
+        console.error('[lint] Gap detection failed:', err instanceof Error ? err.message : err);
+    }
+    // 2. 중복 탐지
+    let dupCount = 0;
+    try {
+        const dups = await detectDuplicates(store, 0.88, 10);
+        dupCount = dups.length;
+        for (const dup of dups) {
+            issues.push({
+                type: 'duplicate',
+                severity: 'warning',
+                message: `Possible duplicate: "${dup.docA.title}" ≈ "${dup.docB.title}" (${Math.round(dup.similarity * 100)}%)`,
+                suggestion: 'Consider merging these notes.',
+            });
+        }
+    }
+    catch (err) {
+        console.error('[lint] Detection failed:', err instanceof Error ? err.message : err);
+    }
+    // 3. 모순 탐지
+    let contradictionCount = 0;
+    try {
+        const contradictions = await detectContradictions(store, 5);
+        contradictionCount = contradictions.length;
+        for (const c of contradictions) {
+            issues.push({
+                type: 'contradiction',
+                severity: 'warning',
+                message: `Potential contradiction: "${c.docA.title}" vs "${c.docB.title}"`,
+                suggestion: 'Review these documents for conflicting information.',
+            });
+        }
+    }
+    catch (err) {
+        console.error('[lint] Detection failed:', err instanceof Error ? err.message : err);
+    }
+    // 4. 빈 문서 / 매우 짧은 문서
+    for (const doc of docs) {
+        if (doc.content.trim().length < 50) {
+            issues.push({
+                type: 'empty',
+                severity: 'info',
+                message: `Very short note: "${doc.title}" (${doc.content.trim().length} chars)`,
+                filePath: doc.filePath,
+                suggestion: 'Consider expanding or removing this note.',
+            });
+        }
+    }
+    // 5. 오래된 문서 (180일 이상 미수정)
+    const now = Date.now();
+    const staleDocs = docs.filter(d => {
+        if (!d.lastModified)
+            return false;
+        const age = (now - new Date(d.lastModified).getTime()) / 86400000;
+        return age > 180;
+    });
+    if (staleDocs.length > totalDocs * 0.3) {
+        suggestions.push(`${staleDocs.length} documents haven't been modified in 6+ months. Run \`stellavault decay\` to review.`);
+    }
+    // 6. 건강도 점수 계산
+    const criticalCount = issues.filter(i => i.severity === 'critical').length;
+    const warningCount = issues.filter(i => i.severity === 'warning').length;
+    const penalty = criticalCount * 10 + warningCount * 3;
+    const score = Math.max(0, Math.min(100, 100 - penalty));
+    // 7. 종합 제안
+    if (gapCount > 5) {
+        suggestions.push(`${gapCount} knowledge gaps found. Start filling the most critical ones.`);
+    }
+    if (dupCount > 3) {
+        suggestions.push(`${dupCount} duplicate documents detected. Run \`stellavault duplicates\` to merge.`);
+    }
+    if (isolatedCount > 10) {
+        suggestions.push(`${isolatedCount} isolated notes found. Add tags or links to connect them.`);
+    }
+    if (totalDocs > 0 && issues.length === 0) {
+        suggestions.push('Your knowledge base is healthy! Keep it up.');
+    }
+    return {
+        score,
+        issues,
+        suggestions,
+        stats: {
+            totalDocs,
+            gaps: gapCount,
+            duplicates: dupCount,
+            contradictions: contradictionCount,
+            isolatedNodes: isolatedCount,
+            orphanTags: 0,
+        },
+    };
+}
+//# sourceMappingURL=knowledge-lint.js.map

package/packages/core/dist/intelligence/wiki-compiler.d.ts

@@ -0,0 +1,30 @@
+export interface CompileResult {
+    rawDocCount: number;
+    wikiArticles: string[];
+    indexFile: string;
+    concepts: string[];
+}
+export interface RawDocument {
+    filePath: string;
+    title: string;
+    content: string;
+    tags: string[];
+}
+/**
+ * raw/ 폴더를 스캔하여 문서 목록 반환
+ */
+export declare function scanRawDirectory(rawPath: string): RawDocument[];
+/**
+ * raw 문서들에서 핵심 개념(concepts) 추출
+ */
+export declare function extractConcepts(docs: RawDocument[]): Map<string, string[]>;
+/**
+ * 컴파일: raw/ → wiki/
+ * - 개념별 문서 생성
+ * - 인덱스 파일 생성
+ * - 백링크 추가
+ */
+export declare function compileWiki(rawPath: string, wikiPath: string, options?: {
+    force?: boolean;
+}): CompileResult;
+//# sourceMappingURL=wiki-compiler.d.ts.map

package/packages/core/dist/intelligence/wiki-compiler.js

@@ -0,0 +1,222 @@
+// Feature: stellavault compile — raw → wiki 컴파일
+// raw/ 폴더의 문서를 분석하여 구조화된 wiki .md 파일 생성
+import { readdirSync, readFileSync, writeFileSync, mkdirSync, existsSync, statSync } from 'node:fs';
+import { join, resolve, basename, extname } from 'node:path';
+/**
+ * raw/ 폴더를 스캔하여 문서 목록 반환
+ */
+export function scanRawDirectory(rawPath) {
+    if (!existsSync(rawPath))
+        return [];
+    const docs = [];
+    const files = readdirSync(rawPath, { recursive: true });
+    for (const file of files) {
+        const fullPath = join(rawPath, file);
+        if (!statSync(fullPath).isFile())
+            continue;
+        const ext = extname(file).toLowerCase();
+        if (!['.md', '.txt', '.html'].includes(ext))
+            continue;
+        const content = readFileSync(fullPath, 'utf-8');
+        const title = extractTitle(content, file);
+        const tags = extractTags(content);
+        docs.push({ filePath: file, title, content, tags });
+    }
+    return docs;
+}
+/**
+ * 문서에서 제목 추출
+ */
+function extractTitle(content, filename) {
+    // YAML frontmatter title
+    const fmMatch = content.match(/^---[\s\S]*?title:\s*["']?(.+?)["']?\s*$/m);
+    if (fmMatch)
+        return fmMatch[1];
+    // First heading
+    const headingMatch = content.match(/^#\s+(.+)$/m);
+    if (headingMatch)
+        return headingMatch[1];
+    // Filename
+    return basename(filename, extname(filename));
+}
+/**
+ * 문서에서 태그 추출
+ */
+function extractTags(content) {
+    const tags = new Set();
+    // YAML tags
+    const fmMatch = content.match(/^---[\s\S]*?tags:\s*\[([^\]]*)\]/m);
+    if (fmMatch) {
+        fmMatch[1].split(',').map(t => t.trim().replace(/["']/g, '')).filter(Boolean).forEach(t => tags.add(t));
+    }
+    // Inline #tags
+    const inlineTags = content.match(/#([a-zA-Z가-힣][a-zA-Z0-9가-힣_-]*)/g) ?? [];
+    inlineTags.forEach(t => tags.add(t.slice(1)));
+    return [...tags];
+}
+/**
+ * raw 문서들에서 핵심 개념(concepts) 추출
+ */
+export function extractConcepts(docs) {
+    const conceptMap = new Map(); // concept → [docPaths]
+    for (const doc of docs) {
+        // 태그를 개념으로
+        for (const tag of doc.tags) {
+            const existing = conceptMap.get(tag) ?? [];
+            existing.push(doc.filePath);
+            conceptMap.set(tag, existing);
+        }
+        // 제목 키워드를 개념으로
+        const titleWords = doc.title
+            .split(/[\s\-_,]+/)
+            .filter(w => w.length > 3)
+            .map(w => w.toLowerCase());
+        for (const word of titleWords) {
+            const existing = conceptMap.get(word) ?? [];
+            existing.push(doc.filePath);
+            conceptMap.set(word, existing);
+        }
+    }
+    // 2개 이상 문서에서 등장하는 개념만
+    const filtered = new Map();
+    for (const [concept, docPaths] of conceptMap) {
+        if (docPaths.length >= 2) {
+            filtered.set(concept, [...new Set(docPaths)]);
+        }
+    }
+    return filtered;
+}
+/**
+ * 컴파일: raw/ → wiki/
+ * - 개념별 문서 생성
+ * - 인덱스 파일 생성
+ * - 백링크 추가
+ */
+export function compileWiki(rawPath, wikiPath, options = {}) {
+    const docs = scanRawDirectory(rawPath);
+    if (docs.length === 0) {
+        return { rawDocCount: 0, wikiArticles: [], indexFile: '', concepts: [] };
+    }
+    // wiki 디렉토리 생성
+    if (!existsSync(wikiPath)) {
+        mkdirSync(wikiPath, { recursive: true });
+    }
+    const concepts = extractConcepts(docs);
+    const wikiArticles = [];
+    // 1. 각 raw 문서의 요약 문서 생성
+    for (const doc of docs) {
+        const slug = doc.title.replace(/[^a-zA-Z0-9가-힣\s]/g, '').replace(/\s+/g, '-').toLowerCase();
+        const wikiFile = `${slug}.md`;
+        const wikiFullPath = resolve(wikiPath, wikiFile);
+        // path traversal 방지
+        if (!wikiFullPath.startsWith(resolve(wikiPath)))
+            continue;
+        const relatedDocs = findRelatedDocs(doc, docs);
+        const articleContent = generateArticle(doc, relatedDocs, concepts);
+        writeFileSync(wikiFullPath, articleContent, 'utf-8');
+        wikiArticles.push(wikiFile);
+    }
+    // 2. 개념별 허브 문서 생성
+    for (const [concept, docPaths] of concepts) {
+        const slug = concept.replace(/[^a-zA-Z0-9가-힣]/g, '-').toLowerCase();
+        const hubFile = `_concept-${slug}.md`;
+        const hubFullPath = resolve(wikiPath, hubFile);
+        if (!hubFullPath.startsWith(resolve(wikiPath)))
+            continue;
+        const relatedArticles = docPaths.map(p => {
+            const doc = docs.find(d => d.filePath === p);
+            return doc?.title ?? p;
+        });
+        const hubContent = [
+            '---',
+            `title: "Concept: ${concept}"`,
+            'type: concept',
+            `date: ${new Date().toISOString()}`,
+            '---',
+            '',
+            `# ${concept}`,
+            '',
+            `This concept appears in ${relatedArticles.length} documents.`,
+            '',
+            '## Related Documents',
+            ...relatedArticles.map(a => `- [[${a}]]`),
+            '',
+            '---',
+            '*Auto-generated by `stellavault compile`*',
+        ].join('\n');
+        writeFileSync(hubFullPath, hubContent, 'utf-8');
+        wikiArticles.push(hubFile);
+    }
+    // 3. 인덱스 파일 생성
+    const indexContent = generateIndex(docs, concepts, wikiArticles);
+    const indexPath = resolve(wikiPath, '_index.md');
+    writeFileSync(indexPath, indexContent, 'utf-8');
+    return {
+        rawDocCount: docs.length,
+        wikiArticles,
+        indexFile: '_index.md',
+        concepts: [...concepts.keys()],
+    };
+}
+function findRelatedDocs(doc, allDocs) {
+    return allDocs
+        .filter(d => d.filePath !== doc.filePath)
+        .filter(d => {
+        const sharedTags = doc.tags.filter(t => d.tags.includes(t));
+        return sharedTags.length > 0;
+    })
+        .slice(0, 5);
+}
+function generateArticle(doc, related, concepts) {
+    const docConcepts = [...concepts.keys()].filter(c => doc.content.toLowerCase().includes(c.toLowerCase()) || doc.tags.includes(c));
+    return [
+        '---',
+        `title: "${doc.title}"`,
+        `source: "${doc.filePath}"`,
+        `date: ${new Date().toISOString()}`,
+        `tags: [${doc.tags.map(t => `"${t}"`).join(', ')}]`,
+        'type: wiki-article',
+        '---',
+        '',
+        `# ${doc.title}`,
+        '',
+        '## Summary',
+        doc.content.substring(0, 500).replace(/^#.+$/gm, '').trim() + '...',
+        '',
+        docConcepts.length > 0 ? `## Related Concepts\n${docConcepts.map(c => `- [[_concept-${c}|${c}]]`).join('\n')}` : '',
+        '',
+        related.length > 0 ? `## 관련 문서\n${related.map(r => `- [[${r.title}]]`).join('\n')}` : '',
+        '',
+        `## Source`,
+        `- Source: \`${doc.filePath}\``,
+        '',
+        '---',
+        '*Compiled by `stellavault compile`*',
+    ].filter(Boolean).join('\n');
+}
+function generateIndex(docs, concepts, articles) {
+    return [
+        '---',
+        'title: "Wiki Index"',
+        `date: ${new Date().toISOString()}`,
+        'type: wiki-index',
+        '---',
+        '',
+        '# Wiki Index',
+        '',
+        `Compiled ${articles.length} wiki articles from ${docs.length} source documents.`,
+        '',
+        '## Concepts',
+        ...[...concepts.entries()]
+            .sort((a, b) => b[1].length - a[1].length)
+            .map(([c, paths]) => `- [[_concept-${c}|${c}]] (${paths.length})`),
+        '',
+        '## Articles',
+        ...docs.map(d => `- [[${d.title}]] — ${d.tags.map(t => `#${t}`).join(' ')}`),
+        '',
+        '---',
+        `*Last compiled: ${new Date().toISOString()}*`,
+        '*Generated by `stellavault compile`*',
+    ].join('\n');
+}
+//# sourceMappingURL=wiki-compiler.js.map

package/packages/core/dist/intelligence/youtube-extractor.d.ts

@@ -0,0 +1,29 @@
+export interface YouTubeContent {
+    title: string;
+    channelName: string;
+    description: string;
+    transcript: TimedSegment[];
+    rawTranscript: string;
+    duration: string;
+    publishDate: string;
+    tags: string[];
+    url: string;
+    videoId: string;
+    viewCount: string;
+    thumbnail: string;
+    summary: string;
+}
+export interface TimedSegment {
+    startTime: number;
+    text: string;
+}
+/**
+ * YouTube URL에서 모든 콘텐츠 추출.
+ * 반환값은 데이터만 — 노트 포맷팅은 별도.
+ */
+export declare function extractYouTubeContent(url: string): Promise<YouTubeContent>;
+/**
+ * 추출된 콘텐츠 → Stellavault .md 노트 (frontmatter 포함하지 않음 — pipeline이 처리).
+ */
+export declare function formatYouTubeNote(content: YouTubeContent): string;
+//# sourceMappingURL=youtube-extractor.d.ts.map