stellavault 0.4.0 → 0.4.2

package/packages/cli/dist/commands/flush-cmd.js

@@ -0,0 +1,58 @@
+// stellavault flush — Daily Logs → Wiki 플러시 (카파시의 Flush Process)
+// Raw daily logs에서 개념/연결 추출 → wiki 갱신
+// "소스 코드를 실행 파일로 컴파일하듯, 원시 데이터를 구조화된 지식으로 변환"
+import chalk from 'chalk';
+import { loadConfig } from '@stellavault/core';
+import { readdirSync, readFileSync, existsSync } from 'node:fs';
+import { resolve, join } from 'node:path';
+export async function flushCommand() {
+    const config = loadConfig();
+    if (!config.vaultPath) {
+        console.error(chalk.red('No vault configured. Run `stellavault init` first.'));
+        process.exit(1);
+    }
+    const folders = config.folders;
+    const logDir = resolve(config.vaultPath, folders.fleeting, '_daily-logs');
+    if (!existsSync(logDir)) {
+        console.log(chalk.yellow('No daily logs found. Use `stellavault session-save` or let Claude Code hooks capture sessions.'));
+        return;
+    }
+    // 1. Daily logs 수집
+    const logFiles = readdirSync(logDir).filter(f => f.startsWith('daily-log-') && f.endsWith('.md'));
+    if (logFiles.length === 0) {
+        console.log(chalk.yellow('No daily log files found.'));
+        return;
+    }
+    console.log(chalk.dim(`Found ${logFiles.length} daily logs`));
+    // 2. 모든 로그에서 세션 요약 추출
+    let totalSessions = 0;
+    const allContent = [];
+    for (const file of logFiles) {
+        const content = readFileSync(join(logDir, file), 'utf-8');
+        const sessions = content.split(/^## Session/m).slice(1);
+        totalSessions += sessions.length;
+        allContent.push(content);
+    }
+    console.log(chalk.dim(`Total sessions: ${totalSessions}`));
+    // 3. Compile: raw/ 전체 (daily-logs 포함) → wiki
+    try {
+        const { compileWiki } = await import('@stellavault/core/intelligence/wiki-compiler');
+        const rawDir = resolve(config.vaultPath, folders.fleeting);
+        const wikiDir = resolve(config.vaultPath, folders.wiki);
+        const result = compileWiki(rawDir, wikiDir);
+        console.log(chalk.green(`Flush complete!`));
+        console.log(chalk.dim(`  Daily logs: ${logFiles.length} files, ${totalSessions} sessions`));
+        console.log(chalk.dim(`  Wiki articles: ${result.wikiArticles.length}`));
+        console.log(chalk.dim(`  Concepts extracted: ${result.concepts.length}`));
+        if (result.concepts.length > 0) {
+            console.log(chalk.dim(`  Top concepts: ${result.concepts.slice(0, 8).join(', ')}`));
+        }
+        console.log(chalk.dim(`  Index: ${result.indexFile}`));
+    }
+    catch (err) {
+        console.error(chalk.red(`Flush failed: ${err instanceof Error ? err.message : 'unknown'}`));
+        process.exit(1);
+    }
+    console.log(chalk.dim('  Tip: Run `stellavault lint` to check knowledge health'));
+}
+//# sourceMappingURL=flush-cmd.js.map

package/packages/cli/dist/commands/ingest-cmd.js

@@ -2,7 +2,7 @@
 import chalk from 'chalk';
 import { loadConfig, ingest, promoteNote } from '@stellavault/core';
 import { readFileSync, existsSync } from 'node:fs';
-import { extname } from 'node:path';
+import { extname, resolve } from 'node:path';
 export async function ingestCommand(input, options) {
     if (!input) {
         console.error(chalk.yellow('Usage: stellavault ingest <url|file|text> [--tags t1,t2] [--stage fleeting|literature|permanent]'));
@@ -85,15 +85,46 @@ export async function ingestCommand(input, options) {
     else if (existsSync(input)) {
         // 파일
         const ext = extname(input).toLowerCase();
-        const fileContent = readFileSync(input, 'utf-8');
-        ingestInput = {
-            type: ext === '.pdf' ? 'pdf-text' : 'file',
-            content: fileContent,
-            tags,
-            stage,
-            title: options.title,
-            source: input,
-        };
+        const binaryExts = new Set(['.pdf', '.docx', '.pptx', '.xlsx', '.xls']);
+        if (binaryExts.has(ext)) {
+            // 바이너리 파일: 전용 파서로 텍스트 추출
+            try {
+                const { extractFileContent } = await import('@stellavault/core/intelligence/file-extractors');
+                const extracted = await extractFileContent(resolve(input));
+                console.log(chalk.dim(`  Extracted ${extracted.metadata.wordCount} words from ${ext} file`));
+                ingestInput = {
+                    type: extracted.sourceFormat,
+                    content: extracted.text,
+                    tags: [...tags, extracted.sourceFormat],
+                    stage, // 제텔카스텐: 모든 인풋은 fleeting에서 시작
+                    title: options.title ?? extracted.metadata.title,
+                    source: input,
+                };
+            }
+            catch (err) {
+                console.error(chalk.yellow(`Binary file extraction failed, saving as-is. (${err instanceof Error ? err.message : 'error'})`));
+                ingestInput = {
+                    type: 'file',
+                    content: readFileSync(input, 'utf-8'),
+                    tags,
+                    stage,
+                    title: options.title,
+                    source: input,
+                };
+            }
+        }
+        else {
+            // 텍스트 파일: 기존 동작
+            const fileContent = readFileSync(input, 'utf-8');
+            ingestInput = {
+                type: 'file',
+                content: fileContent,
+                tags,
+                stage,
+                title: options.title,
+                source: input,
+            };
+        }
     }
     else {
         // 플레인 텍스트
@@ -114,9 +145,8 @@ export async function ingestCommand(input, options) {
         console.log(chalk.dim(`  Index: ${result.indexCode}`));
     if (result.tags.length > 0)
         console.log(chalk.dim(`  Tags: ${result.tags.join(', ')}`));
+    console.log(chalk.dim('  Wiki: auto-compiled'));
     console.log('');
-    console.log(chalk.dim('Run `stellavault compile` to process into wiki.'));
-    console.log(chalk.dim('Run `stellavault autopilot` for full pipeline.'));
 }
 export async function promoteCommand(filePath, options) {
     const config = loadConfig();

package/packages/cli/dist/commands/session-cmd.d.ts

@@ -0,0 +1,7 @@
+export declare function sessionSaveCommand(options: {
+    summary?: string;
+    decisions?: string;
+    lessons?: string;
+    actions?: string;
+}): Promise<void>;
+//# sourceMappingURL=session-cmd.d.ts.map

package/packages/cli/dist/commands/session-cmd.js

@@ -0,0 +1,95 @@
+// stellavault session-save — 세션 요약을 daily log로 자동 저장
+// 카파시 아키텍처: 세션 종료 시 대화의 핵심 결정/교훈/실행항목을 캡처
+// Claude Code hooks의 pre-compact/session-end에서 호출됨
+import chalk from 'chalk';
+import { loadConfig } from '@stellavault/core';
+import { writeFileSync, mkdirSync, existsSync, appendFileSync } from 'node:fs';
+import { resolve, join } from 'node:path';
+export async function sessionSaveCommand(options) {
+    const config = loadConfig();
+    if (!config.vaultPath) {
+        console.error(chalk.red('No vault configured. Run `stellavault init` first.'));
+        process.exit(1);
+    }
+    const folders = config.folders;
+    const logDir = resolve(config.vaultPath, folders.fleeting, '_daily-logs');
+    if (!existsSync(logDir))
+        mkdirSync(logDir, { recursive: true });
+    const now = new Date();
+    const dateStr = now.toISOString().split('T')[0];
+    const timeStr = now.toTimeString().split(' ')[0];
+    const logFile = join(logDir, `daily-log-${dateStr}.md`);
+    // stdin에서 요약 읽기 (Claude Code hook에서 파이프로 전달)
+    let summary = options.summary ?? '';
+    if (!summary && !process.stdin.isTTY) {
+        const chunks = [];
+        for await (const chunk of process.stdin) {
+            chunks.push(chunk);
+        }
+        summary = Buffer.concat(chunks).toString('utf-8').trim();
+    }
+    if (!summary) {
+        // 대화형: 직접 입력
+        console.log(chalk.dim('Enter session summary (Ctrl+D to finish):'));
+        const chunks = [];
+        for await (const chunk of process.stdin) {
+            chunks.push(chunk);
+        }
+        summary = Buffer.concat(chunks).toString('utf-8').trim();
+    }
+    if (!summary) {
+        console.error(chalk.yellow('No summary provided. Skipping.'));
+        return;
+    }
+    // daily log 엔트리 구성
+    const entry = [
+        '',
+        `## Session — ${timeStr}`,
+        '',
+        '### Summary',
+        summary,
+        '',
+    ];
+    if (options.decisions) {
+        entry.push('### Decisions', options.decisions, '');
+    }
+    if (options.lessons) {
+        entry.push('### Lessons Learned', options.lessons, '');
+    }
+    if (options.actions) {
+        entry.push('### Action Items', options.actions, '');
+    }
+    entry.push('---', '');
+    // 파일이 없으면 헤더 생성, 있으면 append
+    if (!existsSync(logFile)) {
+        const header = [
+            '---',
+            `title: "Daily Log — ${dateStr}"`,
+            'type: fleeting',
+            'tags: ["daily-log", "session"]',
+            `created: ${now.toISOString()}`,
+            '---',
+            '',
+            `# Daily Log — ${dateStr}`,
+            '',
+        ].join('\n');
+        writeFileSync(logFile, header + entry.join('\n'), 'utf-8');
+    }
+    else {
+        appendFileSync(logFile, entry.join('\n'), 'utf-8');
+    }
+    console.log(chalk.green(`Session saved to daily log: ${dateStr}`));
+    console.log(chalk.dim(`  File: ${logFile}`));
+    console.log(chalk.dim(`  Time: ${timeStr}`));
+    console.log(chalk.dim(`  Words: ${summary.split(/\s+/).length}`));
+    // 자동 compile 트리거
+    try {
+        const { compileWiki } = await import('@stellavault/core/intelligence/wiki-compiler');
+        const rawDir = resolve(config.vaultPath, folders.fleeting);
+        const wikiDir = resolve(config.vaultPath, folders.wiki);
+        compileWiki(rawDir, wikiDir);
+        console.log(chalk.dim('  Wiki: auto-compiled'));
+    }
+    catch { /* compile 실패해도 저장은 성공 */ }
+}
+//# sourceMappingURL=session-cmd.js.map

package/packages/cli/dist/index.js

@@ -23,6 +23,9 @@ import { vaultAddCommand, vaultListCommand, vaultRemoveCommand, vaultSearchAllCo
 import { captureCommand } from './commands/capture-cmd.js';
 import { askCommand } from './commands/ask-cmd.js';
 import { compileCommand } from './commands/compile-cmd.js';
+import { draftCommand } from './commands/draft-cmd.js';
+import { sessionSaveCommand } from './commands/session-cmd.js';
+import { flushCommand } from './commands/flush-cmd.js';
 import { lintCommand } from './commands/lint-cmd.js';
 import { fleetingCommand } from './commands/fleeting-cmd.js';
 import { ingestCommand, promoteCommand } from './commands/ingest-cmd.js';
@@ -139,6 +142,24 @@ program
     .option('-w, --wiki <dir>', 'Wiki output directory (default: _wiki/)')
     .option('-f, --force', 'Overwrite existing wiki files')
     .action((opts) => compileCommand(opts));
+program
+    .command('draft [topic]')
+    .description('Express: Generate a blog post, report, or outline draft from your knowledge')
+    .option('--format <type>', 'Output format: blog, report, outline (default: blog)')
+    .option('--ai', 'Use Claude API for AI-enhanced draft (requires ANTHROPIC_API_KEY)')
+    .action((topic, opts) => draftCommand(topic, opts));
+program
+    .command('session-save')
+    .description('Save session summary to daily log (used by Claude Code hooks)')
+    .option('-s, --summary <text>', 'Session summary text (or pipe via stdin)')
+    .option('-d, --decisions <text>', 'Key decisions made')
+    .option('-l, --lessons <text>', 'Lessons learned')
+    .option('-a, --actions <text>', 'Action items')
+    .action((opts) => sessionSaveCommand(opts));
+program
+    .command('flush')
+    .description('Flush daily logs → wiki: extract concepts, rebuild connections (Karpathy compile)')
+    .action(() => flushCommand());
 program
     .command('lint')
     .description('Knowledge health check — find gaps, duplicates, contradictions, stale notes')

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/auto-linker.d.ts

@@ -0,0 +1,19 @@
+import { type FolderNames } from '../config.js';
+/**
+ * vault의 모든 .md 노트 제목을 수집.
+ * frontmatter title 또는 첫 heading 또는 파일명.
+ */
+export declare function collectVaultTitles(vaultPath: string, folders?: FolderNames): string[];
+/**
+ * 노트 본문에서 기존 노트 제목/핵심 구문과 매칭하여 [[wikilink]]를 삽입.
+ * - 이미 [[...]]로 감싸진 부분은 건드리지 않음
+ * - frontmatter 영역은 건드리지 않음
+ * - 자기 자신의 제목은 건드리지 않음
+ * - heading(#) 줄은 건드리지 않음
+ */
+export declare function insertWikilinks(body: string, vaultTitles: string[], selfTitle?: string): string;
+/**
+ * vault 스캔 + wikilink 삽입을 한 번에 수행하는 편의 함수.
+ */
+export declare function autoLink(body: string, vaultPath: string, selfTitle?: string, folders?: FolderNames): string;
+//# sourceMappingURL=auto-linker.d.ts.map

package/packages/core/dist/intelligence/auto-linker.js

@@ -0,0 +1,122 @@
+// Auto-Linker: 노트 본문에서 기존 노트 제목과 매칭하여 [[wikilink]] 자동 삽입
+// 제텔카스텐 핵심: 노트 간 연결이 지식 네트워크를 만든다
+import { readdirSync, readFileSync, existsSync } from 'node:fs';
+import { join, resolve, extname } from 'node:path';
+import { DEFAULT_FOLDERS } from '../config.js';
+/**
+ * vault의 모든 .md 노트 제목을 수집.
+ * frontmatter title 또는 첫 heading 또는 파일명.
+ */
+export function collectVaultTitles(vaultPath, folders = DEFAULT_FOLDERS) {
+    const titles = new Set();
+    const dirs = [folders.fleeting, folders.literature, folders.permanent, folders.wiki, '_drafts'];
+    for (const dir of dirs) {
+        const fullDir = resolve(vaultPath, dir);
+        if (!existsSync(fullDir))
+            continue;
+        try {
+            const files = readdirSync(fullDir).filter(f => extname(f) === '.md');
+            for (const file of files) {
+                try {
+                    const content = readFileSync(join(fullDir, file), 'utf-8');
+                    // frontmatter title
+                    const titleMatch = content.match(/^title:\s*"?([^"\n]+)"?\s*$/m);
+                    if (titleMatch && titleMatch[1].length > 2) {
+                        titles.add(titleMatch[1].trim());
+                        continue;
+                    }
+                    // first heading
+                    const headingMatch = content.match(/^#\s+(.+)$/m);
+                    if (headingMatch && headingMatch[1].length > 2) {
+                        titles.add(headingMatch[1].trim());
+                        continue;
+                    }
+                    // filename without extension + timestamp prefix
+                    const name = file.replace(/^\d{4}-\d{2}-\d{2}T[\d-]+-/, '').replace(/\.md$/, '').replace(/-/g, ' ');
+                    if (name.length > 2)
+                        titles.add(name);
+                }
+                catch { /* skip unreadable files */ }
+            }
+        }
+        catch { /* dir not readable */ }
+    }
+    return [...titles].filter(t => t.length > 3); // ignore very short titles
+}
+/**
+ * 제목에서 링크 가능한 핵심 구문(phrases)을 추출.
+ * 예: "Steve Jobs' 2005 Stanford Commencement Address"
+ * → ["Steve Jobs", "Stanford Commencement Address", "Stanford"]
+ */
+function extractLinkablePhrases(title) {
+    const phrases = [];
+    // 전체 제목 (짧으면)
+    if (title.length <= 40)
+        phrases.push(title);
+    // 고유명사/핵심 구문 추출: 대문자로 시작하는 연속 단어
+    const properNouns = title.match(/[A-Z\uAC00-\uD7A3][a-z\uAC00-\uD7A3]+(?:\s+[A-Z\uAC00-\uD7A3][a-z\uAC00-\uD7A3]+)*/g);
+    if (properNouns) {
+        for (const pn of properNouns) {
+            if (pn.length > 4)
+                phrases.push(pn);
+        }
+    }
+    // 한국어: 긴 제목에서 의미 있는 부분 (4글자 이상 한글 연속)
+    const koreanPhrases = title.match(/[\uAC00-\uD7A3]{4,}/g);
+    if (koreanPhrases)
+        phrases.push(...koreanPhrases);
+    return [...new Set(phrases)].filter(p => p.length > 3);
+}
+/**
+ * 노트 본문에서 기존 노트 제목/핵심 구문과 매칭하여 [[wikilink]]를 삽입.
+ * - 이미 [[...]]로 감싸진 부분은 건드리지 않음
+ * - frontmatter 영역은 건드리지 않음
+ * - 자기 자신의 제목은 건드리지 않음
+ * - heading(#) 줄은 건드리지 않음
+ */
+export function insertWikilinks(body, vaultTitles, selfTitle) {
+    if (vaultTitles.length === 0)
+        return body;
+    // frontmatter 분리
+    const fmMatch = body.match(/^(---[\s\S]*?---\n?)/);
+    const frontmatter = fmMatch ? fmMatch[1] : '';
+    let content = fmMatch ? body.slice(frontmatter.length) : body;
+    // 제목 → 링크 가능 구문 매핑
+    const phraseToTitle = new Map();
+    for (const title of vaultTitles) {
+        if (title === selfTitle)
+            continue;
+        for (const phrase of extractLinkablePhrases(title)) {
+            if (!phraseToTitle.has(phrase)) {
+                phraseToTitle.set(phrase, title);
+            }
+        }
+    }
+    // 긴 구문부터 매칭 (짧은 구문이 긴 구문의 부분 매칭되는 것 방지)
+    const sortedPhrases = [...phraseToTitle.keys()].sort((a, b) => b.length - a.length);
+    const linkedPhrases = new Set(); // 이미 링크된 구문 (중복 방지)
+    for (const phrase of sortedPhrases) {
+        const targetTitle = phraseToTitle.get(phrase);
+        if (linkedPhrases.has(targetTitle))
+            continue; // 같은 노트에 여러 구문 매칭 방지
+        const escaped = phrase.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+        const regex = new RegExp(`(?<!\\[\\[)(?<!#\\s)\\b(${escaped})\\b(?!\\]\\])(?![^\\[]*\\]\\])`, 'gi');
+        let replaced = false;
+        content = content.replace(regex, (match) => {
+            if (replaced)
+                return match;
+            replaced = true;
+            linkedPhrases.add(targetTitle);
+            return `[[${targetTitle}|${match}]]`;
+        });
+    }
+    return frontmatter + content;
+}
+/**
+ * vault 스캔 + wikilink 삽입을 한 번에 수행하는 편의 함수.
+ */
+export function autoLink(body, vaultPath, selfTitle, folders = DEFAULT_FOLDERS) {
+    const titles = collectVaultTitles(vaultPath, folders);
+    return insertWikilinks(body, titles, selfTitle);
+}
+//# sourceMappingURL=auto-linker.js.map

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