stellavault 0.3.0 → 0.4.1

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,359 @@ 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' });
+        }
+    });
+    // POST /api/ingest/file — 웹 UI에서 파일 드래그앤드롭 인제스트
+    app.post('/api/ingest/file', async (req, res) => {
+        try {
+            const multer = (await import('multer')).default;
+            const upload = multer({ storage: multer.memoryStorage(), limits: { fileSize: 50 * 1024 * 1024 } });
+            upload.single('file')(req, res, async (uploadErr) => {
+                if (uploadErr) {
+                    res.status(400).json({ error: uploadErr.message || 'Upload failed' });
+                    return;
+                }
+                const file = req.file;
+                if (!file) {
+                    res.status(400).json({ error: 'No file provided' });
+                    return;
+                }
+                // MIME 화이트리스트
+                const allowedMimes = new Set([
+                    'application/pdf',
+                    'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+                    'application/vnd.openxmlformats-officedocument.presentationml.presentation',
+                    'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+                    'application/vnd.ms-excel',
+                    'text/plain', 'text/markdown', 'text/csv',
+                ]);
+                if (!allowedMimes.has(file.mimetype)) {
+                    res.status(400).json({ error: `Unsupported file type: ${file.mimetype}` });
+                    return;
+                }
+                try {
+                    const { writeFileSync, unlinkSync } = await import('node:fs');
+                    const { join } = await import('node:path');
+                    const { tmpdir } = await import('node:os');
+                    const tmpPath = join(tmpdir(), `sv-upload-${Date.now()}-${file.originalname}`);
+                    // 임시 파일 저장 → 파서가 파일 경로 필요
+                    writeFileSync(tmpPath, file.buffer);
+                    const { extractFileContent, isBinaryFormat } = await import('../intelligence/file-extractors.js');
+                    const ext = file.originalname.split('.').pop()?.toLowerCase() ?? '';
+                    const binaryExts = new Set(['pdf', 'docx', 'pptx', 'xlsx', 'xls']);
+                    let content;
+                    let extractedTitle;
+                    let formatTag = ext;
+                    if (binaryExts.has(ext)) {
+                        const extracted = await extractFileContent(tmpPath);
+                        content = extracted.text;
+                        extractedTitle = extracted.metadata.title;
+                        formatTag = extracted.sourceFormat;
+                    }
+                    else {
+                        content = file.buffer.toString('utf-8');
+                    }
+                    // 임시 파일 삭제
+                    try {
+                        unlinkSync(tmpPath);
+                    }
+                    catch { /* ok */ }
+                    // locale 설정
+                    const locale = req.body?.locale;
+                    if (locale) {
+                        const { setNoteLocale } = await import('../i18n/note-strings.js');
+                        setNoteLocale(locale);
+                    }
+                    const tags = req.body?.tags ? (Array.isArray(req.body.tags) ? req.body.tags : req.body.tags.split(',').map((t) => t.trim())) : [];
+                    const { ingest } = await import('../intelligence/ingest-pipeline.js');
+                    const result = ingest(vaultPath, {
+                        type: formatTag,
+                        content,
+                        tags: [...tags, formatTag],
+                        title: req.body?.title ?? extractedTitle,
+                        stage: 'fleeting',
+                        source: file.originalname,
+                    });
+                    // 자동 인덱싱
+                    try {
+                        const doc = {
+                            id: require('node:crypto').createHash('sha256').update(result.savedTo).digest('hex').slice(0, 16),
+                            filePath: result.savedTo,
+                            title: result.title,
+                            content,
+                            frontmatter: {},
+                            tags: result.tags,
+                            lastModified: new Date().toISOString(),
+                            contentHash: '',
+                            source: 'upload',
+                            type: result.stage,
+                        };
+                        await store.upsertDocument(doc);
+                    }
+                    catch (indexErr) {
+                        console.error('[ingest/file] 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) {
+                    res.status(500).json({ error: err instanceof Error ? err.message : 'Processing failed' });
+                }
+            });
+        }
+        catch (err) {
+            res.status(500).json({ error: 'File upload initialization 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/config.d.ts

@@ -1,6 +1,13 @@
+export interface FolderNames {
+    fleeting: string;
+    literature: string;
+    permanent: string;
+    wiki: string;
+}
 export interface StellavaultConfig {
     vaultPath: string;
     dbPath: string;
+    folders: FolderNames;
     embedding: {
         model: 'local' | 'openai';
         localModel: string;
@@ -19,6 +26,7 @@ export interface StellavaultConfig {
         port: number;
     };
 }
+export declare const DEFAULT_FOLDERS: FolderNames;
 /**
  * .stellavault.json 파일을 찾아 로드합니다.
  * 탐색 순서: cwd → home directory → defaults

package/packages/core/dist/config.js

@@ -2,12 +2,19 @@
 import { readFileSync, existsSync } from 'node:fs';
 import { resolve, join } from 'node:path';
 import { homedir } from 'node:os';
+export const DEFAULT_FOLDERS = {
+    fleeting: 'raw',
+    literature: '_literature',
+    permanent: '_permanent',
+    wiki: '_wiki',
+};
 const DEFAULT_CONFIG = {
     vaultPath: '',
     dbPath: join(homedir(), '.stellavault', 'index.db'),
+    folders: { ...DEFAULT_FOLDERS },
     embedding: {
         model: 'local',
-        localModel: 'all-MiniLM-L6-v2',
+        localModel: 'paraphrase-multilingual-MiniLM-L12-v2',
     },
     chunking: {
         maxTokens: 300,
@@ -46,6 +53,7 @@ function mergeConfig(defaults, overrides) {
     return {
         vaultPath: overrides.vaultPath ?? defaults.vaultPath,
         dbPath: overrides.dbPath ?? defaults.dbPath,
+        folders: { ...defaults.folders, ...overrides.folders },
         embedding: { ...defaults.embedding, ...overrides.embedding },
         chunking: { ...defaults.chunking, ...overrides.chunking },
         search: { ...defaults.search, ...overrides.search },

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

@@ -1,5 +1,5 @@
-export { loadConfig } from './config.js';
-export type { StellavaultConfig } from './config.js';
+export { loadConfig, DEFAULT_FOLDERS } from './config.js';
+export type { StellavaultConfig, FolderNames } from './config.js';
 export type { Document } from './types/document.js';
 export type { Chunk, ScoredChunk } from './types/chunk.js';
 export type { SearchResult, SearchOptions, TopicInfo, StoreStats, } from './types/search.js';
@@ -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

@@ -1,6 +1,6 @@
 // Design Ref: §4.2 — Core Internal API (Facade)
 // Design Ref: §9.3 — Dependency Injection Pattern
-export { loadConfig } from './config.js';
+export { loadConfig, DEFAULT_FOLDERS } from './config.js';
 // Store
 export { createSqliteVecStore } from './store/index.js';
 // Indexer
@@ -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