stellavault 0.3.0 → 0.4.0

package/packages/core/dist/api/server.js

@@ -41,6 +41,43 @@ export function createApiServer(options) {
             res.status(500).json({ error: 'Internal server error' });
         }
     });
+    // POST /api/reindex — 웹에서 인덱싱 트리거
+    let isReindexing = false;
+    app.post('/api/reindex', async (_req, res) => {
+        if (isReindexing) {
+            res.json({ success: false, error: '인덱싱이 이미 진행 중입니다' });
+            return;
+        }
+        isReindexing = true;
+        try {
+            const indexer = await import('../indexer/index.js');
+            const embedder = indexer.createLocalEmbedder('all-MiniLM-L6-v2');
+            await embedder.initialize();
+            const result = await indexer.indexVault(vaultPath, {
+                store,
+                embedder,
+                onProgress: (current, total) => {
+                    if (current % 50 === 0)
+                        console.error(`[reindex] ${current}/${total}`);
+                },
+            });
+            // 그래프 캐시 리셋
+            graphCaches.clear();
+            res.json({
+                success: true,
+                indexed: result.indexed,
+                skipped: result.skipped,
+                chunks: result.totalChunks,
+            });
+        }
+        catch (err) {
+            console.error('[reindex]', err);
+            res.status(500).json({ error: `Reindex failed: ${err?.message ?? String(err)}` });
+        }
+        finally {
+            isReindexing = false;
+        }
+    });
     // GET /api/search?q=&limit=
     app.get('/api/search', async (req, res) => {
         try {
@@ -62,7 +99,10 @@ export function createApiServer(options) {
                 results: results.map(r => ({
                     documentId: r.document.id,
                     title: r.document.title,
+                    filePath: r.document.filePath,
                     score: Math.round(r.score * 1000) / 1000,
+                    snippet: r.chunk?.content?.substring(0, 200) ?? '',
+                    tags: r.document.tags ?? [],
                     highlights: r.highlights,
                 })),
                 query,
@@ -213,6 +253,250 @@ export function createApiServer(options) {
             res.status(500).json({ error: 'Internal server error' });
         }
     });
+    // PUT /api/document/:id — 노트 편집 (vault 파일 직접 수정)
+    app.put('/api/document/:id', async (req, res) => {
+        try {
+            const { id } = req.params;
+            const { title, content, tags } = req.body;
+            const doc = await store.getDocument(id);
+            if (!doc) {
+                res.status(404).json({ error: 'Document not found' });
+                return;
+            }
+            const { resolve, join } = await import('node:path');
+            const { writeFileSync, readFileSync } = await import('node:fs');
+            const fullPath = resolve(vaultPath, doc.filePath);
+            // path traversal 방지
+            if (!fullPath.startsWith(resolve(vaultPath))) {
+                res.status(403).json({ error: 'Access denied' });
+                return;
+            }
+            // 기존 파일 읽기
+            const existing = readFileSync(fullPath, 'utf-8');
+            // frontmatter 업데이트
+            let updated = existing;
+            if (title && title !== doc.title) {
+                updated = updated.replace(/^title:\s*.+$/m, `title: "${title.replace(/"/g, "''")}"`);
+            }
+            if (tags) {
+                const tagStr = `tags: [${tags.map((t) => `"${t}"`).join(', ')}]`;
+                if (updated.match(/^tags:\s*.+$/m)) {
+                    updated = updated.replace(/^tags:\s*.+$/m, tagStr);
+                }
+            }
+            if (content !== undefined) {
+                // frontmatter 이후 본문 교체
+                const fmEnd = updated.indexOf('---', 4);
+                if (fmEnd > 0) {
+                    const fm = updated.substring(0, fmEnd + 3);
+                    updated = fm + '\n\n' + content;
+                }
+                else {
+                    updated = content;
+                }
+            }
+            writeFileSync(fullPath, updated, 'utf-8');
+            // DB 업데이트
+            await store.upsertDocument({
+                ...doc,
+                title: title ?? doc.title,
+                content: content ?? doc.content,
+                tags: tags ?? doc.tags,
+                lastModified: new Date().toISOString(),
+            });
+            res.json({ success: true, id, title: title ?? doc.title });
+        }
+        catch (err) {
+            console.error('[edit]', err);
+            res.status(500).json({ error: err?.message ?? 'Edit failed' });
+        }
+    });
+    // DELETE /api/document/:id — 노트 삭제 (vault 파일 + DB)
+    app.delete('/api/document/:id', async (req, res) => {
+        try {
+            const { id } = req.params;
+            const doc = await store.getDocument(id);
+            if (!doc) {
+                res.status(404).json({ error: 'Document not found' });
+                return;
+            }
+            const { resolve } = await import('node:path');
+            const { unlinkSync, existsSync } = await import('node:fs');
+            const fullPath = resolve(vaultPath, doc.filePath);
+            // path traversal 방지
+            if (!fullPath.startsWith(resolve(vaultPath))) {
+                res.status(403).json({ error: 'Access denied' });
+                return;
+            }
+            // 파일 삭제
+            if (existsSync(fullPath)) {
+                unlinkSync(fullPath);
+            }
+            // DB에서 삭제
+            await store.deleteByDocumentId(id);
+            res.json({ success: true, id, deleted: doc.filePath });
+        }
+        catch (err) {
+            console.error('[delete]', err);
+            res.status(500).json({ error: err?.message ?? 'Delete failed' });
+        }
+    });
+    // GET /api/ask — 웹 UI Q&A
+    app.get('/api/ask', async (req, res) => {
+        try {
+            const question = String(req.query.q || '');
+            if (!question) {
+                res.json({ question: '', answer: '', sources: [] });
+                return;
+            }
+            const { askVault } = await import('../intelligence/ask-engine.js');
+            const result = await askVault(searchEngine, question, {
+                limit: 10,
+                save: req.query.save === 'true',
+                vaultPath,
+            });
+            res.json(result);
+        }
+        catch (err) {
+            console.error(err);
+            res.status(500).json({ error: 'Ask failed' });
+        }
+    });
+    // POST /api/ingest — 웹 UI에서 URL/텍스트 인제스트
+    app.post('/api/ingest', async (req, res) => {
+        try {
+            const { input, type, tags, title, stage, locale } = req.body;
+            // 노트 언어 설정
+            if (locale) {
+                const { setNoteLocale } = await import('../i18n/note-strings.js');
+                setNoteLocale(locale);
+            }
+            if (!input || typeof input !== 'string') {
+                res.status(400).json({ error: 'input is required' });
+                return;
+            }
+            // URL인 경우 제목+내용 가져오기
+            let content = input;
+            let autoTitle = title;
+            let autoTags = tags ?? [];
+            let autoStage = stage ?? 'fleeting';
+            const isYouTube = /youtube\.com\/watch|youtu\.be\//.test(input);
+            if (isYouTube) {
+                // YouTube 전용: 자막 + 메타데이터 추출
+                try {
+                    const { extractYouTubeContent, formatYouTubeNote } = await import('../intelligence/youtube-extractor.js');
+                    const ytContent = await extractYouTubeContent(input);
+                    autoTitle = ytContent.title;
+                    autoTags = [...new Set(['youtube', ...ytContent.tags, ...(tags ?? [])])];
+                    autoStage = 'literature';
+                    // formatYouTubeNote는 frontmatter 없이 본문만 생성 → pipeline이 frontmatter 담당
+                    content = formatYouTubeNote(ytContent);
+                }
+                catch (ytErr) {
+                    console.error('[ingest] YouTube extraction failed, falling back to basic:', ytErr instanceof Error ? ytErr.message : ytErr);
+                    // 폴백: 기본 HTML 추출
+                    try {
+                        const resp = await fetch(input, { signal: AbortSignal.timeout(8000) });
+                        const html = await resp.text();
+                        const titleMatch = html.match(/<title[^>]*>([^<]+)<\/title>/i);
+                        if (titleMatch && !autoTitle)
+                            autoTitle = titleMatch[1].trim();
+                        content = input + '\n\n' + html.replace(/<[^>]+>/g, ' ').replace(/\s+/g, ' ').trim().slice(0, 5000);
+                    }
+                    catch { /* URL만 저장 */ }
+                }
+            }
+            else if (input.startsWith('http')) {
+                // 일반 웹페이지
+                try {
+                    const resp = await fetch(input, { signal: AbortSignal.timeout(8000) });
+                    const html = await resp.text();
+                    const titleMatch = html.match(/<title[^>]*>([^<]+)<\/title>/i);
+                    if (titleMatch && !autoTitle)
+                        autoTitle = titleMatch[1].trim();
+                    const text = html
+                        .replace(/<script[\s\S]*?<\/script>/gi, '')
+                        .replace(/<style[\s\S]*?<\/style>/gi, '')
+                        .replace(/<[^>]+>/g, ' ')
+                        .replace(/&nbsp;/g, ' ')
+                        .replace(/&amp;/g, '&')
+                        .replace(/&lt;/g, '<')
+                        .replace(/&gt;/g, '>')
+                        .replace(/\s+/g, ' ')
+                        .trim()
+                        .slice(0, 5000);
+                    content = input + '\n\n' + text;
+                }
+                catch { /* URL만 저장 */ }
+            }
+            const { ingest } = await import('../intelligence/ingest-pipeline.js');
+            const result = ingest(vaultPath, {
+                type: type ?? (isYouTube ? 'youtube' : input.startsWith('http') ? 'url' : 'text'),
+                content,
+                tags: autoTags,
+                title: autoTitle,
+                stage: autoStage,
+                source: input.startsWith('http') ? input : undefined,
+            });
+            // 저장 후 자동 인덱싱 (그래프에 바로 반영)
+            try {
+                const fullPath = require('node:path').resolve(vaultPath, result.savedTo);
+                const { chunkDocument } = await import('../indexer/index.js');
+                const doc = {
+                    id: require('node:crypto').createHash('sha256').update(result.savedTo).digest('hex').slice(0, 16),
+                    filePath: result.savedTo,
+                    title: result.title,
+                    content: content,
+                    frontmatter: {},
+                    tags: result.tags,
+                    lastModified: new Date().toISOString(),
+                    contentHash: '',
+                    source: 'ingest',
+                    type: result.stage,
+                };
+                await store.upsertDocument(doc);
+            }
+            catch (indexErr) {
+                console.error('[ingest] Auto-index failed:', indexErr instanceof Error ? indexErr.message : indexErr);
+            }
+            res.json({
+                success: true,
+                savedTo: result.savedTo,
+                stage: result.stage,
+                title: result.title,
+                indexCode: result.indexCode,
+                tags: result.tags,
+                wordCount: result.wordCount,
+            });
+        }
+        catch (err) {
+            console.error(err);
+            res.status(500).json({ error: 'Ingest failed' });
+        }
+    });
+    // GET /api/recent — 최근 저장된 노트 목록
+    app.get('/api/recent', async (_req, res) => {
+        try {
+            const docs = await store.getAllDocuments();
+            const recent = docs
+                .filter(d => d.lastModified)
+                .sort((a, b) => new Date(b.lastModified).getTime() - new Date(a.lastModified).getTime())
+                .slice(0, 20)
+                .map(d => ({
+                id: d.id,
+                title: d.title,
+                filePath: d.filePath,
+                lastModified: d.lastModified,
+                tags: d.tags.slice(0, 5),
+                type: d.type ?? 'note',
+            }));
+            res.json({ recent });
+        }
+        catch (err) {
+            console.error(err);
+            res.status(500).json({ error: 'Failed' });
+        }
+    });
     // GET /api/heatmap — Design Ref: §2.2 — 지식 히트맵 활동 점수
     app.get('/api/heatmap', async (_req, res) => {
         try {

package/packages/core/dist/i18n/note-strings.d.ts

@@ -0,0 +1,5 @@
+export type NoteLocale = 'en' | 'ko' | 'ja' | 'zh';
+export declare function setNoteLocale(locale: NoteLocale): void;
+export declare function getNoteLocale(): NoteLocale;
+export declare function nt(key: string): string;
+//# sourceMappingURL=note-strings.d.ts.map

package/packages/core/dist/i18n/note-strings.js

@@ -0,0 +1,94 @@
+// 저장 노트용 다국어 문자열 — 사용자 언어에 따라 노트 섹션 제목 결정
+const strings = {
+    en: {
+        'summary': 'Summary',
+        'description': 'Description',
+        'transcript': 'Transcript',
+        'views': 'Views',
+        'relatedDocs': 'Related Documents',
+        'relatedConcepts': 'Related Concepts',
+        'relatedTags': 'Related Tags',
+        'source': 'Source',
+        'articles': 'Articles',
+        'concepts': 'Concepts',
+        'exploreFurther': 'Explore Further',
+        'noResults': 'No results found',
+        'tryDifferent': 'Try different keywords or create a note on this topic.',
+        'digDeeper': 'Dig deeper',
+        'findGaps': 'Find knowledge gaps',
+        'thisConceptAppears': 'This concept appears in',
+        'documents': 'documents',
+        'compiledFrom': 'Compiled',
+        'wikiArticlesFrom': 'wiki articles from',
+        'sourceDocuments': 'source documents',
+        'staleWarning': "documents haven't been modified in 6+ months. Run `stellavault decay` to review.",
+        'gapsFound': 'knowledge gaps found. Start filling the most critical ones.',
+        'duplicatesFound': 'duplicate documents detected. Run `stellavault duplicates` to merge.',
+        'isolatedFound': 'isolated notes found. Add tags or links to connect them.',
+        'healthy': 'Your knowledge base is healthy! Keep it up.',
+        'youtubeVideo': 'YouTube video',
+    },
+    ko: {
+        'summary': '핵심 요약',
+        'description': '설명',
+        'transcript': '영상 내용',
+        'views': '조회수',
+        'relatedDocs': '관련 문서',
+        'relatedConcepts': '관련 개념',
+        'relatedTags': '관련 태그',
+        'source': '원본',
+        'articles': '문서 목록',
+        'concepts': '개념',
+        'exploreFurther': '더 알아보기',
+        'noResults': '검색 결과 없음',
+        'tryDifferent': '다른 키워드로 검색하거나, 이 주제에 대한 노트를 작성해보세요.',
+        'digDeeper': '더 깊이 알아보기',
+        'findGaps': '빠진 지식 찾기',
+        'thisConceptAppears': '이 개념이 등장하는 문서',
+        'documents': '개',
+        'compiledFrom': '컴파일됨',
+        'wikiArticlesFrom': '개 위키 문서 생성 (원본',
+        'sourceDocuments': '개)',
+        'staleWarning': '개 문서가 6개월 이상 수정되지 않았어요. `stellavault decay`로 확인하세요.',
+        'gapsFound': '개 지식 빈틈이 발견됐어요. 중요한 것부터 채워보세요.',
+        'duplicatesFound': '개 겹치는 문서가 있어요. `stellavault duplicates`로 합치세요.',
+        'isolatedFound': '개 떨어진 노트가 있어요. 태그나 링크로 연결하세요.',
+        'healthy': '지식이 건강해요! 계속 유지하세요.',
+        'youtubeVideo': 'YouTube 영상',
+    },
+    ja: {
+        'summary': '要約',
+        'description': '説明',
+        'transcript': '内容',
+        'views': '再生回数',
+        'relatedDocs': '関連ドキュメント',
+        'relatedConcepts': '関連コンセプト',
+        'source': 'ソース',
+        'noResults': '検索結果なし',
+        'healthy': 'ナレッジベースは健全です！',
+        'youtubeVideo': 'YouTube動画',
+    },
+    zh: {
+        'summary': '摘要',
+        'description': '描述',
+        'transcript': '内容',
+        'views': '观看次数',
+        'relatedDocs': '相关文档',
+        'relatedConcepts': '相关概念',
+        'source': '来源',
+        'noResults': '未找到结果',
+        'healthy': '知识库很健康！',
+        'youtubeVideo': 'YouTube视频',
+    },
+};
+let currentNoteLocale = 'en';
+export function setNoteLocale(locale) {
+    currentNoteLocale = locale;
+}
+export function getNoteLocale() {
+    return currentNoteLocale;
+}
+export function nt(key) {
+    return strings[currentNoteLocale]?.[key] ?? strings.en[key] ?? key;
+}
+//# sourceMappingURL=note-strings.js.map

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

@@ -29,6 +29,15 @@ export { predictKnowledgeGaps } from './intelligence/predictive-gaps.js';
 export type { PredictedGap } from './intelligence/predictive-gaps.js';
 export type { DuplicatePair } from './intelligence/duplicate-detector.js';
 export { generateLearningPath } from './intelligence/learning-path.js';
+export { askVault } from './intelligence/ask-engine.js';
+export { compileWiki, scanRawDirectory, extractConcepts } from './intelligence/wiki-compiler.js';
+export { lintKnowledge } from './intelligence/knowledge-lint.js';
+export { scanFrontmatter, generateNextIndexCode, assignIndexCodes, getInboxItems, archiveFile, checkAtomicity, detectOrphansAndBrokenLinks, } from './intelligence/zettelkasten.js';
+export type { FrontmatterEntry } from './intelligence/zettelkasten.js';
+export { ingest, ingestBatch, promoteNote } from './intelligence/ingest-pipeline.js';
+export type { IngestInput, IngestResult, NoteStage } from './intelligence/ingest-pipeline.js';
+export type { LintResult, LintIssue } from './intelligence/knowledge-lint.js';
+export type { AskResult } from './intelligence/ask-engine.js';
 export type { LearningPath, LearningItem, LearningPathInput } from './intelligence/learning-path.js';
 export { checkNotifications } from './intelligence/notifications.js';
 export type { Notification, NotificationConfig } from './intelligence/notifications.js';

package/packages/core/dist/index.js

@@ -22,6 +22,11 @@ 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 { askVault } from './intelligence/ask-engine.js';
+export { compileWiki, scanRawDirectory, extractConcepts } from './intelligence/wiki-compiler.js';
+export { lintKnowledge } from './intelligence/knowledge-lint.js';
+export { scanFrontmatter, generateNextIndexCode, assignIndexCodes, getInboxItems, archiveFile, checkAtomicity, detectOrphansAndBrokenLinks, } from './intelligence/zettelkasten.js';
+export { ingest, ingestBatch, promoteNote } from './intelligence/ingest-pipeline.js';
 export { checkNotifications } from './intelligence/notifications.js';
 // Multi-Vault
 export { addVault, removeVault, listVaults, getVault, searchAllVaults } from './multi-vault/index.js';

package/packages/core/dist/intelligence/ask-engine.d.ts

@@ -0,0 +1,23 @@
+import type { SearchEngine } from '../search/index.js';
+export interface AskResult {
+    question: string;
+    answer: string;
+    sources: Array<{
+        title: string;
+        filePath: string;
+        score: number;
+        snippet: string;
+    }>;
+    savedTo: string | null;
+}
+/**
+ * 질문에 대해 vault를 검색하고 구조화된 답변을 생성.
+ * LLM 없이 검색 결과를 구조화하는 버전 (LLM 연동은 MCP ask tool에서 처리).
+ */
+export declare function askVault(searchEngine: SearchEngine, question: string, options?: {
+    limit?: number;
+    save?: boolean;
+    vaultPath?: string;
+    outputDir?: string;
+}): Promise<AskResult>;
+//# sourceMappingURL=ask-engine.d.ts.map

package/packages/core/dist/intelligence/ask-engine.js

@@ -0,0 +1,108 @@
+// Feature: stellavault ask — Q&A + auto-filing
+// vault 대상 자연어 질문 → 검색 → 답변 구조화 → vault에 .md 저장
+import { writeFileSync, mkdirSync, existsSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+/**
+ * 질문에 대해 vault를 검색하고 구조화된 답변을 생성.
+ * LLM 없이 검색 결과를 구조화하는 버전 (LLM 연동은 MCP ask tool에서 처리).
+ */
+export async function askVault(searchEngine, question, options = {}) {
+    const { limit = 10, save = false, vaultPath, outputDir = '_stellavault/answers' } = options;
+    // 1. 검색
+    const results = await searchEngine.search({ query: question, limit });
+    // 2. 소스 정리
+    const sources = results.map((r) => ({
+        title: r.document.title,
+        filePath: r.document.filePath,
+        score: Math.round(r.score * 1000) / 1000,
+        snippet: r.chunk?.content?.substring(0, 200) ?? '',
+    }));
+    // 3. 답변 구성 (검색 결과 기반 구조화)
+    const answer = composeAnswer(question, results);
+    // 4. vault에 저장 (선택)
+    let savedTo = null;
+    if (save && vaultPath) {
+        savedTo = saveAnswerToVault(question, answer, sources, vaultPath, outputDir);
+    }
+    return { question, answer, sources, savedTo };
+}
+/**
+ * 검색 결과를 구조화된 답변으로 구성.
+ * LLM 없이도 유용한 요약을 만듦.
+ */
+function composeAnswer(question, results) {
+    if (results.length === 0) {
+        return `No results found for "${question}". Try different keywords or create a note on this topic.`;
+    }
+    const lines = [];
+    lines.push(`## ${question}\n`);
+    // Related documents
+    lines.push(`### Related Documents (${results.length})\n`);
+    for (const r of results.slice(0, 5)) {
+        const score = Math.round(r.score * 100);
+        lines.push(`- **${r.document.title}** (${score}% 관련)`);
+        if (r.chunk?.content) {
+            const snippet = r.chunk.content.substring(0, 150).replace(/\n/g, ' ').trim();
+            lines.push(`  > ${snippet}...`);
+        }
+        if (r.document.tags.length > 0) {
+            lines.push(`  Tags: ${r.document.tags.map(t => `#${t}`).join(' ')}`);
+        }
+        lines.push('');
+    }
+    // Related tags
+    const allTags = new Set();
+    for (const r of results) {
+        r.document.tags.forEach((t) => allTags.add(t));
+    }
+    if (allTags.size > 0) {
+        lines.push(`### Related Tags`);
+        lines.push([...allTags].map(t => `#${t}`).join(' '));
+        lines.push('');
+    }
+    // Explore further
+    lines.push(`### Explore Further`);
+    lines.push(`- Dig deeper: \`stellavault ask "${question} advanced"\``);
+    lines.push(`- Find knowledge gaps: \`stellavault gaps\``);
+    return lines.join('\n');
+}
+/**
+ * 답변을 vault에 .md 파일로 저장.
+ * "_stellavault/answers/YYYY-MM-DD-question.md" 형식.
+ */
+function saveAnswerToVault(question, answer, sources, vaultPath, outputDir) {
+    const dir = resolve(vaultPath, outputDir);
+    if (!existsSync(dir)) {
+        mkdirSync(dir, { recursive: true });
+    }
+    const date = new Date().toISOString().split('T')[0];
+    const slug = question
+        .toLowerCase()
+        .replace(/[^a-z0-9가-힣\s]/g, '')
+        .replace(/\s+/g, '-')
+        .substring(0, 60);
+    const filename = `${date}-${slug}.md`;
+    const filePath = join(outputDir, filename);
+    const fullPath = resolve(vaultPath, filePath);
+    // vault 경로 내인지 확인 (path traversal 방지)
+    if (!fullPath.startsWith(resolve(vaultPath))) {
+        throw new Error('Invalid output path');
+    }
+    const content = [
+        '---',
+        `title: "${question}"`,
+        `date: ${new Date().toISOString()}`,
+        'type: answer',
+        'source: stellavault-ask',
+        `tags: [${sources.slice(0, 5).flatMap(s => s.title.split(/\s+/).slice(0, 2)).map(t => `"${t}"`).join(', ')}]`,
+        '---',
+        '',
+        answer,
+        '',
+        '---',
+        '*Generated by `stellavault ask`. Sources from your vault.*',
+    ].join('\n');
+    writeFileSync(fullPath, content, 'utf-8');
+    return filePath;
+}
+//# sourceMappingURL=ask-engine.js.map

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

@@ -0,0 +1,31 @@
+export type NoteStage = 'fleeting' | 'literature' | 'permanent';
+export interface IngestInput {
+    type: 'url' | 'text' | 'file' | 'youtube' | 'pdf-text';
+    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): IngestResult;
+/**
+ * 여러 입력을 배치 처리.
+ */
+export declare function ingestBatch(vaultPath: string, inputs: IngestInput[]): IngestResult[];
+/**
+ * 노트 승격: fleeting → literature → permanent.
+ * 내용이 충분히 정제되면 다음 단계로 이동.
+ */
+export declare function promoteNote(vaultPath: string, filePath: string, targetStage: NoteStage): string;
+//# sourceMappingURL=ingest-pipeline.d.ts.map