stellavault 0.3.0 → 0.4.1

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

@@ -0,0 +1,32 @@
+import { type FolderNames } from '../config.js';
+export type NoteStage = 'fleeting' | 'literature' | 'permanent';
+export interface IngestInput {
+    type: 'url' | 'text' | 'file' | 'youtube' | 'pdf-text' | 'pdf' | 'docx' | 'pptx' | 'xlsx' | 'xls';
+    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, folders?: FolderNames): IngestResult;
+/**
+ * 여러 입력을 배치 처리.
+ */
+export declare function ingestBatch(vaultPath: string, inputs: IngestInput[]): IngestResult[];
+/**
+ * 노트 승격: fleeting → literature → permanent.
+ * 내용이 충분히 정제되면 다음 단계로 이동.
+ */
+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

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