stellavault 0.3.0 → 0.4.0

package/packages/core/dist/intelligence/ingest-pipeline.js

@@ -0,0 +1,192 @@
+// 통합 인제스트 파이프라인
+// 어떤 입력이든 → Stellavault 포맷으로 자동 변환 + 분류 + 연결
+//
+// 지원 입력: URL, PDF 텍스트, 마크다운, 플레인텍스트, YouTube
+// 출력: frontmatter 포맷 .md → raw/ → compile → lint
+import { writeFileSync, mkdirSync, existsSync, readFileSync } from 'node:fs';
+import { join, resolve, basename } from 'node:path';
+import { scanFrontmatter, assignIndexCodes, archiveFile } from './zettelkasten.js';
+/** YAML 값에서 위험한 문자를 이스케이프 */
+function sanitizeYaml(val) {
+    return val.replace(/["\\]/g, '\\$&').replace(/\n/g, ' ').slice(0, 200);
+}
+/**
+ * 어떤 입력이든 Stellavault 표준 포맷으로 변환하여 저장.
+ */
+export function ingest(vaultPath, input) {
+    const stage = input.stage ?? 'fleeting';
+    const title = input.title ?? extractTitleFromContent(input.content, input.type);
+    const tags = input.tags ?? extractAutoTags(input.content, input.type);
+    const source = input.source ?? (input.type === 'url' || input.type === 'youtube' ? input.content.split('\n')[0] : 'manual');
+    // 본문 정리
+    const body = cleanContent(input.content, input.type);
+    const wordCount = body.split(/\s+/).length;
+    // 자동 분류: 길이/구조에 따라 stage 결정
+    const autoStage = classifyStage(body, stage, wordCount);
+    // 폴더 결정
+    const folderMap = {
+        fleeting: 'raw',
+        literature: '_literature',
+        permanent: '_permanent',
+    };
+    const folder = folderMap[autoStage];
+    const dir = resolve(vaultPath, folder);
+    if (!existsSync(dir))
+        mkdirSync(dir, { recursive: true });
+    // 파일명 생성
+    const now = new Date();
+    const timestamp = now.toISOString().replace(/[:.]/g, '-').slice(0, 19);
+    const slug = title.slice(0, 50).replace(/[^a-zA-Z0-9가-힣\s]/g, '').replace(/\s+/g, '-').toLowerCase();
+    const filename = `${timestamp}-${slug}.md`;
+    const filePath = join(folder, filename);
+    const fullPath = resolve(vaultPath, filePath);
+    // path traversal 방지
+    if (!fullPath.startsWith(resolve(vaultPath))) {
+        throw new Error('Invalid path');
+    }
+    // 인덱스 코드 생성 (lazy — 전체 스캔 건너뛸 수 있음)
+    let indexCode;
+    try {
+        // 성능: raw/ 폴더만 스캔 (전체 vault 스캔 대신)
+        const rawEntries = scanFrontmatter(resolve(vaultPath, folder));
+        const assignments = assignIndexCodes([...rawEntries, {
+                filePath, title, tags, connections: [], wordCount,
+            }]);
+        indexCode = assignments.get(filePath);
+    }
+    catch { /* index code is optional */ }
+    // Stellavault 표준 포맷으로 저장
+    const md = buildStandardNote({
+        title,
+        body,
+        tags,
+        stage: autoStage,
+        source,
+        indexCode,
+        created: now.toISOString(),
+        inputType: input.type,
+    });
+    writeFileSync(fullPath, md, 'utf-8');
+    return {
+        savedTo: filePath,
+        stage: autoStage,
+        title,
+        indexCode,
+        tags,
+        wordCount,
+    };
+}
+/**
+ * 여러 입력을 배치 처리.
+ */
+export function ingestBatch(vaultPath, inputs) {
+    return inputs.map(input => ingest(vaultPath, input));
+}
+/**
+ * 노트 승격: fleeting → literature → permanent.
+ * 내용이 충분히 정제되면 다음 단계로 이동.
+ */
+export function promoteNote(vaultPath, filePath, targetStage) {
+    const fullPath = resolve(vaultPath, filePath);
+    if (!existsSync(fullPath))
+        throw new Error(`File not found: ${filePath}`);
+    const content = readFileSync(fullPath, 'utf-8');
+    // frontmatter의 type 변경
+    const updated = content.replace(/^type:\s*.+$/m, `type: ${targetStage}`);
+    // 대상 폴더로 이동
+    const folderMap = {
+        fleeting: 'raw',
+        literature: '_literature',
+        permanent: '_permanent',
+    };
+    const newDir = resolve(vaultPath, folderMap[targetStage]);
+    if (!existsSync(newDir))
+        mkdirSync(newDir, { recursive: true });
+    const newPath = join(folderMap[targetStage], basename(filePath));
+    const newFullPath = resolve(vaultPath, newPath);
+    if (!newFullPath.startsWith(resolve(vaultPath))) {
+        throw new Error('Invalid path');
+    }
+    writeFileSync(newFullPath, updated, 'utf-8');
+    // 원본에 archive 플래그
+    archiveFile(fullPath);
+    return newPath;
+}
+// ─── 내부 헬퍼 ───
+function extractTitleFromContent(content, type) {
+    if (type === 'url' || type === 'youtube') {
+        // URL에서 도메인 + 경로 추출
+        try {
+            const url = new URL(content.split('\n')[0]);
+            return url.hostname + url.pathname.slice(0, 40);
+        }
+        catch {
+            return 'Untitled Clip';
+        }
+    }
+    // 첫 heading 또는 첫 줄
+    const heading = content.match(/^#\s+(.+)$/m);
+    if (heading)
+        return heading[1];
+    const firstLine = content.split('\n')[0].trim();
+    return firstLine.slice(0, 80) || 'Untitled';
+}
+function extractAutoTags(content, type) {
+    const tags = new Set();
+    // 입력 타입 태그
+    if (type === 'url')
+        tags.add('web-clip');
+    if (type === 'youtube')
+        tags.add('youtube');
+    if (type === 'pdf-text')
+        tags.add('pdf');
+    // 인라인 #태그 추출
+    const inline = content.match(/#([a-zA-Z가-힣][a-zA-Z0-9가-힣_-]{2,})/g) ?? [];
+    inline.forEach(t => tags.add(t.slice(1)));
+    return [...tags].slice(0, 10);
+}
+function cleanContent(content, type) {
+    if (type === 'url' || type === 'youtube') {
+        // URL은 첫 줄이 URL, 나머지가 내용
+        const lines = content.split('\n');
+        return lines.slice(1).join('\n').trim() || lines[0];
+    }
+    return content.trim();
+}
+function classifyStage(body, requestedStage, wordCount) {
+    // 요청된 단계가 permanent면 그대로
+    if (requestedStage === 'permanent')
+        return 'permanent';
+    // 자동 분류 기준:
+    // - 200단어 미만 + 구조 없음 → fleeting
+    // - 200-1000단어 + 출처 있음 → literature
+    // - 1000단어+ + 구조 있음 → permanent 후보 (but 수동 승격 권장)
+    if (wordCount < 200 && !body.includes('## '))
+        return 'fleeting';
+    if (wordCount >= 200 && (body.includes('## ') || body.includes('> ')))
+        return 'literature';
+    return requestedStage;
+}
+function buildStandardNote(params) {
+    const lines = [
+        '---',
+        `title: "${sanitizeYaml(params.title)}"`,
+        `type: ${params.stage}`,
+        `source: ${params.source}`,
+        `input_type: ${params.inputType}`,
+        params.indexCode ? `zettel_id: "${params.indexCode}"` : null,
+        `tags: [${params.tags.map(t => `"${t}"`).join(', ')}]`,
+        `created: ${params.created}`,
+        `summary: "${sanitizeYaml(params.body.slice(0, 100))}"`,
+        '---',
+        '',
+        `# ${params.title}`,
+        '',
+        params.body,
+        '',
+        '---',
+        `*Ingested via \`stellavault ingest\` (${params.inputType}) at ${params.created}*`,
+    ];
+    return lines.filter(l => l !== null).join('\n');
+}
+//# sourceMappingURL=ingest-pipeline.js.map

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