stellavault 0.4.0 → 0.4.1

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

@@ -474,6 +474,115 @@ export function createApiServer(options) {
             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 {

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/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';

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

package/packages/core/dist/intelligence/draft-generator.d.ts

@@ -0,0 +1,19 @@
+import { type FolderNames } from '../config.js';
+export interface DraftOptions {
+    topic?: string;
+    format?: 'blog' | 'report' | 'outline';
+    maxSections?: number;
+}
+export interface DraftResult {
+    title: string;
+    filePath: string;
+    wordCount: number;
+    sourceCount: number;
+    concepts: string[];
+}
+/**
+ * vault의 wiki 데이터를 기반으로 초안(draft)을 생성.
+ * Express 단계: 지식이 vault에서 나가는 출구.
+ */
+export declare function generateDraft(vaultPath: string, options?: DraftOptions, folders?: FolderNames): DraftResult;
+//# sourceMappingURL=draft-generator.d.ts.map

package/packages/core/dist/intelligence/draft-generator.js

@@ -0,0 +1,161 @@
+// Express 단계: stellavault draft — wiki 기반 초안 생성
+// Plan SC: SC3 (Express)
+// 카파시의 "자가 컴파일" 결과물을 외부로 표현하는 출구
+import { writeFileSync, mkdirSync, existsSync } from 'node:fs';
+import { join, resolve, basename, extname } from 'node:path';
+import { scanRawDirectory, extractConcepts } from './wiki-compiler.js';
+import { DEFAULT_FOLDERS } from '../config.js';
+/**
+ * vault의 wiki 데이터를 기반으로 초안(draft)을 생성.
+ * Express 단계: 지식이 vault에서 나가는 출구.
+ */
+export function generateDraft(vaultPath, options = {}, folders = DEFAULT_FOLDERS) {
+    const { topic, format = 'blog', maxSections = 8 } = options;
+    // raw + wiki 문서 스캔
+    const rawDir = resolve(vaultPath, folders.fleeting);
+    const wikiDir = resolve(vaultPath, folders.wiki);
+    const litDir = resolve(vaultPath, folders.literature);
+    const allDocs = [];
+    for (const dir of [rawDir, wikiDir, litDir]) {
+        if (existsSync(dir)) {
+            allDocs.push(...scanRawDirectory(dir));
+        }
+    }
+    if (allDocs.length === 0) {
+        throw new Error('No documents found in vault. Run `stellavault ingest` first.');
+    }
+    // 토픽 필터
+    const filteredDocs = topic
+        ? allDocs.filter(d => d.tags.some(t => t.toLowerCase().includes(topic.toLowerCase())) ||
+            d.title.toLowerCase().includes(topic.toLowerCase()) ||
+            d.content.toLowerCase().includes(topic.toLowerCase()))
+        : allDocs;
+    if (filteredDocs.length === 0) {
+        throw new Error(`No documents found for topic "${topic}". Try a broader term.`);
+    }
+    // 개념 추출
+    const concepts = extractConcepts(filteredDocs);
+    const topConcepts = [...concepts.entries()]
+        .sort((a, b) => b[1].length - a[1].length)
+        .slice(0, maxSections);
+    // 초안 생성
+    const draftTitle = topic
+        ? `Draft: ${topic}`
+        : `Knowledge Draft — ${new Date().toISOString().split('T')[0]}`;
+    let body;
+    switch (format) {
+        case 'outline':
+            body = generateOutline(draftTitle, topConcepts, filteredDocs);
+            break;
+        case 'report':
+            body = generateReport(draftTitle, topConcepts, filteredDocs);
+            break;
+        case 'blog':
+        default:
+            body = generateBlog(draftTitle, topConcepts, filteredDocs);
+            break;
+    }
+    const wordCount = body.split(/\s+/).filter(Boolean).length;
+    // _drafts/ 폴더에 저장
+    const draftsDir = resolve(vaultPath, '_drafts');
+    if (!existsSync(draftsDir))
+        mkdirSync(draftsDir, { recursive: true });
+    const timestamp = new Date().toISOString().replace(/[:.]/g, '-').slice(0, 19);
+    const slug = (topic ?? 'knowledge').replace(/[^a-zA-Z0-9가-힣\s]/g, '').replace(/\s+/g, '-').toLowerCase().slice(0, 40);
+    const filename = `${timestamp}-${slug}.md`;
+    const filePath = join('_drafts', filename);
+    const fullPath = resolve(vaultPath, filePath);
+    writeFileSync(fullPath, body, 'utf-8');
+    return {
+        title: draftTitle,
+        filePath,
+        wordCount,
+        sourceCount: filteredDocs.length,
+        concepts: topConcepts.map(([c]) => c),
+    };
+}
+// ─── 포맷별 생성기 ───
+function generateBlog(title, concepts, docs) {
+    const lines = [];
+    lines.push(`# ${title}`, '');
+    lines.push(`> Auto-generated from ${docs.length} knowledge notes`, '');
+    // 도입부: 전체 주제 요약
+    lines.push('## Introduction', '');
+    const topicWords = concepts.slice(0, 3).map(([c]) => c).join(', ');
+    lines.push(`This post explores ${topicWords} based on ${docs.length} curated knowledge notes.`, '');
+    // 섹션별: 개념 + 관련 문서 발췌
+    for (const [concept, docPaths] of concepts) {
+        lines.push(`## ${capitalize(concept)}`, '');
+        const relatedDocs = docs.filter(d => docPaths.includes(d.filePath) ||
+            d.tags.includes(concept) ||
+            d.title.toLowerCase().includes(concept.toLowerCase())).slice(0, 3);
+        for (const doc of relatedDocs) {
+            const excerpt = extractExcerpt(doc.content, 150);
+            if (excerpt) {
+                lines.push(`> ${excerpt}`, `> — *${doc.title}*`, '');
+            }
+        }
+        lines.push('<!-- TODO: Add your analysis and insights here -->', '');
+    }
+    // 참고 자료
+    lines.push('## References', '');
+    const uniqueDocs = [...new Map(docs.map(d => [d.filePath, d])).values()].slice(0, 20);
+    for (const doc of uniqueDocs) {
+        lines.push(`- [[${basename(doc.filePath, extname(doc.filePath))}|${doc.title}]]`);
+    }
+    lines.push('');
+    lines.push(`---`, `*Generated by \`stellavault draft\` at ${new Date().toISOString()}*`);
+    return lines.join('\n');
+}
+function generateReport(title, concepts, docs) {
+    const lines = [];
+    lines.push(`# ${title}`, '');
+    lines.push(`**Date:** ${new Date().toISOString().split('T')[0]}`);
+    lines.push(`**Sources:** ${docs.length} documents`);
+    lines.push(`**Key Topics:** ${concepts.map(([c]) => c).join(', ')}`, '');
+    lines.push('## Executive Summary', '');
+    lines.push('<!-- TODO: Write 2-3 sentence summary -->', '');
+    for (const [concept, docPaths] of concepts) {
+        lines.push(`## ${capitalize(concept)}`, '');
+        lines.push(`**Related documents:** ${docPaths.length}`, '');
+        const relatedDocs = docs.filter(d => docPaths.includes(d.filePath)).slice(0, 3);
+        for (const doc of relatedDocs) {
+            const excerpt = extractExcerpt(doc.content, 200);
+            if (excerpt)
+                lines.push(`- ${excerpt} *(${doc.title})*`);
+        }
+        lines.push('');
+        lines.push('**Analysis:** <!-- TODO -->', '');
+    }
+    lines.push('## Conclusion', '', '<!-- TODO -->', '');
+    lines.push(`---`, `*Generated by \`stellavault draft\` at ${new Date().toISOString()}*`);
+    return lines.join('\n');
+}
+function generateOutline(title, concepts, docs) {
+    const lines = [];
+    lines.push(`# ${title} — Outline`, '');
+    lines.push(`Sources: ${docs.length} documents`, '');
+    for (let i = 0; i < concepts.length; i++) {
+        const [concept, docPaths] = concepts[i];
+        lines.push(`${i + 1}. **${capitalize(concept)}** (${docPaths.length} sources)`);
+        const relatedDocs = docs.filter(d => docPaths.includes(d.filePath)).slice(0, 3);
+        for (const doc of relatedDocs) {
+            lines.push(`   - ${doc.title}`);
+        }
+    }
+    lines.push('', `---`, `*Generated by \`stellavault draft\` at ${new Date().toISOString()}*`);
+    return lines.join('\n');
+}
+// ─── 유틸 ───
+function extractExcerpt(content, maxLen) {
+    // frontmatter 제거
+    const body = content.replace(/^---[\s\S]*?---\n?/, '').replace(/^#+\s+.+\n/m, '').trim();
+    // 첫 의미 있는 문단
+    const paragraphs = body.split(/\n\n+/).filter(p => p.length > 20 && !p.startsWith('> ') && !p.startsWith('- '));
+    const first = paragraphs[0] ?? '';
+    return first.length > maxLen ? first.slice(0, maxLen) + '...' : first;
+}
+function capitalize(s) {
+    return s.charAt(0).toUpperCase() + s.slice(1);
+}
+//# sourceMappingURL=draft-generator.js.map

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

@@ -0,0 +1,18 @@
+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;
+/**
+ * 파일 경로에서 텍스트 추출. 확장자 기반 파서 디스패치.
+ * 지원: .pdf, .docx, .pptx, .xlsx, .xls
+ * 미지원 확장자: utf-8 텍스트로 읽기
+ */
+export declare function extractFileContent(filePath: string): Promise<ExtractedContent>;
+//# sourceMappingURL=file-extractors.d.ts.map

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

@@ -0,0 +1,127 @@
+// Design Ref: §file-ingest-v2 — Binary file text extraction dispatchers
+// Plan SC: SC1-SC5 (format-specific extraction + fallback)
+import { readFileSync } 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 텍스트로 읽기
+ */
+export async function extractFileContent(filePath) {
+    const ext = extname(filePath).toLowerCase();
+    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 text = workbook.SheetNames
+            .map((name) => {
+            const csv = XLSX.utils.sheet_to_csv(workbook.Sheets[name]);
+            return `## ${name}\n\n${csv}`;
+        })
+            .join('\n\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/ingest-pipeline.d.ts

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

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

@@ -6,6 +6,8 @@
 import { writeFileSync, mkdirSync, existsSync, readFileSync } from 'node:fs';
 import { join, resolve, basename } from 'node:path';
 import { scanFrontmatter, assignIndexCodes, archiveFile } from './zettelkasten.js';
+import { compileWiki } from './wiki-compiler.js';
+import { DEFAULT_FOLDERS } from '../config.js';
 /** YAML 값에서 위험한 문자를 이스케이프 */
 function sanitizeYaml(val) {
     return val.replace(/["\\]/g, '\\$&').replace(/\n/g, ' ').slice(0, 200);
@@ -13,7 +15,7 @@ function sanitizeYaml(val) {
 /**
  * 어떤 입력이든 Stellavault 표준 포맷으로 변환하여 저장.
  */
-export function ingest(vaultPath, input) {
+export function ingest(vaultPath, input, folders = DEFAULT_FOLDERS) {
     const stage = input.stage ?? 'fleeting';
     const title = input.title ?? extractTitleFromContent(input.content, input.type);
     const tags = input.tags ?? extractAutoTags(input.content, input.type);
@@ -23,11 +25,11 @@ export function ingest(vaultPath, input) {
     const wordCount = body.split(/\s+/).length;
     // 자동 분류: 길이/구조에 따라 stage 결정
     const autoStage = classifyStage(body, stage, wordCount);
-    // 폴더 결정
+    // 폴더 결정 (config-driven)
     const folderMap = {
-        fleeting: 'raw',
-        literature: '_literature',
-        permanent: '_permanent',
+        fleeting: folders.fleeting,
+        literature: folders.literature,
+        permanent: folders.permanent,
     };
     const folder = folderMap[autoStage];
     const dir = resolve(vaultPath, folder);
@@ -67,6 +69,15 @@ export function ingest(vaultPath, input) {
         inputType: input.type,
     });
     writeFileSync(fullPath, md, 'utf-8');
+    // 자동 compile: fleeting → wiki (rule-based, <100ms)
+    try {
+        const rawDir = resolve(vaultPath, folders.fleeting);
+        const wikiDir = resolve(vaultPath, folders.wiki);
+        if (existsSync(rawDir)) {
+            compileWiki(rawDir, wikiDir);
+        }
+    }
+    catch { /* compile 실패해도 ingest 성공 */ }
     return {
         savedTo: filePath,
         stage: autoStage,
@@ -86,18 +97,18 @@ export function ingestBatch(vaultPath, inputs) {
  * 노트 승격: fleeting → literature → permanent.
  * 내용이 충분히 정제되면 다음 단계로 이동.
  */
-export function promoteNote(vaultPath, filePath, targetStage) {
+export function promoteNote(vaultPath, filePath, targetStage, folders = DEFAULT_FOLDERS) {
     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}`);
-    // 대상 폴더로 이동
+    // 대상 폴더로 이동 (config-driven)
     const folderMap = {
-        fleeting: 'raw',
-        literature: '_literature',
-        permanent: '_permanent',
+        fleeting: folders.fleeting,
+        literature: folders.literature,
+        permanent: folders.permanent,
     };
     const newDir = resolve(vaultPath, folderMap[targetStage]);
     if (!existsSync(newDir))
@@ -138,8 +149,14 @@ function extractAutoTags(content, type) {
         tags.add('web-clip');
     if (type === 'youtube')
         tags.add('youtube');
-    if (type === 'pdf-text')
+    if (type === 'pdf-text' || type === 'pdf')
         tags.add('pdf');
+    if (type === 'docx')
+        tags.add('document');
+    if (type === 'pptx')
+        tags.add('presentation');
+    if (type === 'xlsx' || type === 'xls')
+        tags.add('spreadsheet');
     // 인라인 #태그 추출
     const inline = content.match(/#([a-zA-Z가-힣][a-zA-Z0-9가-힣_-]{2,})/g) ?? [];
     inline.forEach(t => tags.add(t.slice(1)));

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

@@ -18,6 +18,7 @@ import { createDetectGapsTool } from './tools/detect-gaps.js';
 import { createGetEvolutionTool } from './tools/get-evolution.js';
 import { createLinkCodeTool } from './tools/link-code.js';
 import { createAskTool } from './tools/ask.js';
+import { createGenerateDraftTool } from './tools/generate-draft.js';
 import { createAgenticGraphTools } from './tools/agentic-graph.js';
 export function createMcpServer(options) {
     const { store, searchEngine, embedder, vaultPath = '', decayEngine } = options;
@@ -26,6 +27,7 @@ export function createMcpServer(options) {
     const getEvolutionTool = createGetEvolutionTool(store);
     const linkCodeTool = createLinkCodeTool(searchEngine);
     const askTool = createAskTool(searchEngine, vaultPath);
+    const generateDraftTool = createGenerateDraftTool(searchEngine, vaultPath);
     const agenticTools = embedder ? createAgenticGraphTools(store, embedder, vaultPath) : [];
     const server = new Server({ name: 'stellavault', version: '0.2.0' }, { capabilities: { tools: {} } });
     // List tools
@@ -40,6 +42,7 @@ export function createMcpServer(options) {
             { name: getEvolutionTool.name, description: getEvolutionTool.description, inputSchema: getEvolutionTool.inputSchema },
             { name: linkCodeTool.name, description: linkCodeTool.description, inputSchema: linkCodeTool.inputSchema },
             { name: askTool.name, description: askTool.description, inputSchema: askTool.inputSchema },
+            { name: generateDraftTool.name, description: generateDraftTool.description, inputSchema: generateDraftTool.inputSchema },
             ...agenticTools.map(t => ({ name: t.name, description: t.description, inputSchema: t.inputSchema })),
         ],
     }));
@@ -120,6 +123,9 @@ export function createMcpServer(options) {
                 case 'ask':
                     result = await askTool.handler(args);
                     return result;
+                case 'generate-draft':
+                    result = await generateDraftTool.handler(args);
+                    return result;
                 default:
                     {
                         // Agentic graph tools (create-knowledge-node, create-knowledge-link)