stellavault 0.3.0 → 0.4.0

package/packages/core/dist/intelligence/youtube-extractor.js

@@ -0,0 +1,311 @@
+// YouTube 콘텐츠 추출기 v2 — 자막(타임스탬프 보존) + 메타데이터 → 구조화 노트
+// PM 분석 반영: HTML 엔티티, 채널명, 이중 frontmatter, 태그 품질, 요약 품질
+import { nt } from '../i18n/note-strings.js';
+/**
+ * YouTube URL에서 모든 콘텐츠 추출.
+ * 반환값은 데이터만 — 노트 포맷팅은 별도.
+ */
+export async function extractYouTubeContent(url) {
+    const html = await fetchPage(url);
+    // 메타데이터 (cleanHtml 먼저 적용)
+    const title = cleanHtml(extractMeta(html, 'og:title') ?? extractBetween(html, '<title>', '</title>') ?? 'Untitled');
+    const channelName = cleanHtml(extractBetween(html, '"ownerChannelName":"', '"')
+        ?? extractBetween(html, '"author":"', '"')
+        ?? 'Unknown Channel');
+    // 전체 설명 가져오기 (og:description은 ~150자로 잘림)
+    const description = cleanHtml(extractFullDescription(html));
+    const duration = extractBetween(html, '"lengthSeconds":"', '"') ?? '';
+    const publishDate = extractBetween(html, '"publishDate":"', '"') ?? '';
+    const viewCount = extractBetween(html, '"viewCount":"', '"') ?? '';
+    const thumbnail = extractMeta(html, 'og:image') ?? '';
+    const videoId = extractVideoId(url);
+    // 자막 (타임스탬프 보존)
+    let transcript = [];
+    let rawTranscript = '';
+    try {
+        transcript = await extractTimedTranscript(html, videoId);
+        rawTranscript = transcript.map(s => s.text).join(' ');
+    }
+    catch { /* 자막 없음 */ }
+    // 태그 (cleanHtml 적용된 데이터에서 추출)
+    const tags = extractSmartTags(title, description);
+    // 요약 (문장 중요도 기반)
+    const summary = generateSmartSummary(title, rawTranscript, description);
+    return {
+        title, channelName, description, transcript, rawTranscript,
+        duration: formatDuration(duration), publishDate, tags, url,
+        videoId, viewCount, thumbnail, summary,
+    };
+}
+/**
+ * 추출된 콘텐츠 → Stellavault .md 노트 (frontmatter 포함하지 않음 — pipeline이 처리).
+ */
+export function formatYouTubeNote(content) {
+    const lines = [];
+    // Header
+    lines.push(`# ${content.title}`, '');
+    lines.push(`> **${content.channelName}** | ${content.duration} | ${content.publishDate?.split('T')[0] ?? ''}`);
+    if (content.viewCount)
+        lines.push(`> ${nt('views')}: ${Number(content.viewCount).toLocaleString()}`);
+    lines.push(`> ${content.url}`, '');
+    if (content.summary) {
+        lines.push(`## ${nt('summary')}`, '', content.summary, '');
+    }
+    if (content.description.length > 30) {
+        lines.push(`## ${nt('description')}`, '', content.description.slice(0, 3000), '');
+    }
+    if (content.transcript.length > 0) {
+        lines.push(`## ${nt('transcript')}`, '');
+        const segments = groupIntoSegments(content.transcript);
+        for (const seg of segments) {
+            const ts = formatSeconds(seg.startTime);
+            const ytLink = `https://youtu.be/${content.videoId}?t=${Math.floor(seg.startTime)}`;
+            lines.push(`### [${ts}](${ytLink})`, '', seg.text, '');
+        }
+    }
+    return lines.join('\n');
+}
+// ─── 자막 추출 (타임스탬프 보존) ───
+async function extractTimedTranscript(html, videoId) {
+    // 1차: HTML에서 captionTracks URL 직접 fetch
+    const segments = await extractTimedTranscriptFromHtml(html);
+    if (segments.length > 0)
+        return segments;
+    // 2차: yt-dlp fallback (YouTube bot 보호 우회)
+    if (videoId)
+        return extractTimedTranscriptViaTool(videoId);
+    return [];
+}
+async function extractTimedTranscriptFromHtml(html) {
+    const captionMatch = html.match(/"captionTracks":\[(.*?)\]/);
+    if (!captionMatch)
+        return [];
+    const tracks = captionMatch[1];
+    let captionUrl = '';
+    const allUrls = [...tracks.matchAll(/"baseUrl":"(.*?)"/g)].map(m => m[1]);
+    const allLangs = [...tracks.matchAll(/"languageCode":"(.*?)"/g)].map(m => m[1]);
+    for (const targetLang of ['ko', 'en']) {
+        const idx = allLangs.indexOf(targetLang);
+        if (idx >= 0 && allUrls[idx]) {
+            captionUrl = allUrls[idx];
+            break;
+        }
+    }
+    if (!captionUrl && allUrls.length > 0)
+        captionUrl = allUrls[0];
+    if (!captionUrl)
+        return [];
+    const cleanUrl = captionUrl.replace(/\\u0026/g, '&').replace(/\\u003d/g, '=').replace(/\\\//g, '/');
+    const resp = await fetch(cleanUrl, { signal: AbortSignal.timeout(10000) });
+    const xml = await resp.text();
+    return parseTranscriptXml(xml);
+}
+async function extractTimedTranscriptViaTool(videoId) {
+    const { execSync } = await import('node:child_process');
+    const { readdirSync, readFileSync, unlinkSync } = await import('node:fs');
+    const { join } = await import('node:path');
+    const tmpDir = (await import('node:os')).tmpdir();
+    const tmpBase = join(tmpDir, `sv-sub-${videoId}`);
+    const url = `https://www.youtube.com/watch?v=${videoId}`;
+    // Try each language separately to avoid partial failure aborting everything
+    for (const lang of ['ko', 'en']) {
+        try {
+            execSync(`python -m yt_dlp --write-auto-sub --sub-lang ${lang} --skip-download --sub-format srv1 -o "${tmpBase}" "${url}"`, { timeout: 30000, stdio: 'pipe' });
+        }
+        catch { /* lang not available — try next */
+            continue;
+        }
+        // Find the subtitle file
+        const files = readdirSync(tmpDir).filter(f => f.startsWith(`sv-sub-${videoId}`) && f.endsWith('.srv1'));
+        if (files.length === 0)
+            continue;
+        const xml = readFileSync(join(tmpDir, files[0]), 'utf-8');
+        // Cleanup
+        for (const f of files) {
+            try {
+                unlinkSync(join(tmpDir, f));
+            }
+            catch { /* ok */ }
+        }
+        const segments = parseTranscriptXml(xml);
+        if (segments.length > 0)
+            return segments;
+    }
+    return [];
+}
+function parseTranscriptXml(xml) {
+    if (!xml || xml.length === 0)
+        return [];
+    const segments = [];
+    const matches = xml.matchAll(/<text start="([^"]+)"[^>]*>(.*?)<\/text>/g);
+    for (const m of matches) {
+        const text = cleanHtml(m[2]).trim();
+        if (text)
+            segments.push({ startTime: parseFloat(m[1]), text });
+    }
+    return segments;
+}
+function groupIntoSegments(timedTexts, gapThreshold = 30) {
+    const segments = [];
+    let current = null;
+    let lastStart = 0;
+    for (const item of timedTexts) {
+        if (!current || (item.startTime - lastStart > gapThreshold)) {
+            if (current)
+                segments.push(current);
+            current = { startTime: item.startTime, texts: [] };
+        }
+        current.texts.push(item.text);
+        lastStart = item.startTime;
+    }
+    if (current)
+        segments.push(current);
+    return segments.map(s => ({ startTime: s.startTime, text: s.texts.join(' ') }));
+}
+// ─── 태그 추출 (한국어 조사 처리) ───
+function extractSmartTags(title, description) {
+    const text = `${title} ${title} ${description}`; // 제목 가중치 2배
+    const koSuffixes = ['에서는', '에서', '에게', '까지', '부터', '으로', '에는', '와', '과', '을', '를', '이', '가', '은', '는', '의', '에', '로', '도', '만'];
+    const stopwords = new Set([
+        'this', 'that', 'with', 'from', 'have', 'been', 'will', 'about',
+        'your', 'more', 'what', 'http', 'https', 'www', 'youtube', 'com',
+        '이번', '영상', '에서', '있는', '하는', '것을', '합니다', '있습니다',
+        '안녕하세요', '바이브랩스입니다', '됩니다', '그리고', '하지만', '이렇게',
+    ]);
+    const tokens = text.split(/[\s,.\-_#|?!'"()\[\]{}:;]+/).filter(Boolean);
+    const freq = new Map();
+    for (let token of tokens) {
+        // 한국어 조사 제거
+        if (token.length > 2) {
+            for (const suffix of koSuffixes) {
+                if (token.endsWith(suffix) && token.length - suffix.length >= 2) {
+                    token = token.slice(0, -suffix.length);
+                    break;
+                }
+            }
+        }
+        if (token.length < 2 || /^\d+$/.test(token) || stopwords.has(token.toLowerCase()))
+            continue;
+        if (/&[a-z]+;|&#\d+;/.test(token))
+            continue;
+        freq.set(token, (freq.get(token) ?? 0) + 1);
+    }
+    return [...freq.entries()]
+        .sort((a, b) => b[1] - a[1])
+        .slice(0, 6)
+        .map(([w]) => w);
+}
+// ─── 요약 (문장 중요도 기반) ───
+function generateSmartSummary(title, transcript, description) {
+    const source = transcript.length > 100 ? transcript : description;
+    if (source.length < 50)
+        return `${title} — ${nt('youtubeVideo')}`;
+    const sentences = source
+        .split(/[.。!?]\s+|(?<=다)\s+|(?<=요)\s+/)
+        .map(s => s.trim())
+        .filter(s => s.length > 15 && s.length < 300);
+    if (sentences.length <= 3)
+        return sentences.join(' ');
+    const titleWords = new Set(title.split(/[\s,.\-_]+/).filter(w => w.length > 2).map(w => w.toLowerCase()));
+    const scored = sentences.map((sentence, idx) => {
+        let score = 0;
+        const words = sentence.toLowerCase().split(/\s+/);
+        for (const w of words) {
+            if (titleWords.has(w))
+                score += 3;
+        }
+        const pos = idx / sentences.length;
+        if (pos > 0.15 && pos < 0.4)
+            score += 2;
+        if (pos > 0.6 && pos < 0.85)
+            score += 1;
+        if (pos < 0.05)
+            score -= 3; // 인트로 인사 강력 패널티
+        if (/\d+/.test(sentence))
+            score += 1;
+        return { sentence, score, idx };
+    });
+    return scored
+        .sort((a, b) => b.score - a.score)
+        .slice(0, 4)
+        .sort((a, b) => a.idx - b.idx)
+        .map(s => s.sentence)
+        .join(' ');
+}
+// ─── 유틸 ───
+function extractFullDescription(html) {
+    // 방법 1: JSON에서 shortDescription 추출 (이스케이프된 JSON 문자열)
+    const shortDescMatch = html.match(/"shortDescription":"((?:[^"\\]|\\.)*)"/);
+    if (shortDescMatch) {
+        try {
+            return JSON.parse(`"${shortDescMatch[1]}"`);
+        }
+        catch { /* fallback */ }
+    }
+    // 방법 2: description.simpleText
+    const simpleMatch = html.match(/"description":\{"simpleText":"((?:[^"\\]|\\.)*)"/);
+    if (simpleMatch) {
+        try {
+            return JSON.parse(`"${simpleMatch[1]}"`);
+        }
+        catch { /* fallback */ }
+    }
+    // 방법 3: og:description (짧지만 최후 수단)
+    return extractMeta(html, 'og:description') ?? '';
+}
+async function fetchPage(url) {
+    const resp = await fetch(url, {
+        headers: {
+            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36',
+            'Accept-Language': 'ko-KR,ko;q=0.9,en;q=0.8',
+        },
+        signal: AbortSignal.timeout(15000),
+    });
+    return resp.text();
+}
+function extractMeta(html, property) {
+    const match = html.match(new RegExp(`<meta[^>]*property="${property}"[^>]*content="([^"]*)"`, 'i'))
+        ?? html.match(new RegExp(`<meta[^>]*name="${property}"[^>]*content="([^"]*)"`, 'i'));
+    return match?.[1];
+}
+function extractBetween(html, start, end) {
+    const idx = html.indexOf(start);
+    if (idx < 0)
+        return undefined;
+    const s = idx + start.length;
+    const e = html.indexOf(end, s);
+    if (e < 0)
+        return undefined;
+    return html.substring(s, e);
+}
+function cleanHtml(text) {
+    return text
+        .replace(/&amp;/g, '&').replace(/&lt;/g, '<').replace(/&gt;/g, '>')
+        .replace(/&#39;/g, "'").replace(/&quot;/g, '"').replace(/&#x27;/g, "'")
+        .replace(/&nbsp;/g, ' ').replace(/\\n/g, ' ').replace(/\n/g, ' ')
+        .trim();
+}
+function formatDuration(seconds) {
+    const s = parseInt(seconds);
+    if (isNaN(s))
+        return '';
+    const h = Math.floor(s / 3600);
+    const m = Math.floor((s % 3600) / 60);
+    const sec = s % 60;
+    return h > 0 ? `${h}:${String(m).padStart(2, '0')}:${String(sec).padStart(2, '0')}` : `${m}:${String(sec).padStart(2, '0')}`;
+}
+function formatSeconds(sec) {
+    const m = Math.floor(sec / 60);
+    const s = Math.floor(sec % 60);
+    return `${m}:${String(s).padStart(2, '0')}`;
+}
+function extractVideoId(url) {
+    try {
+        const u = new URL(url);
+        return u.searchParams.get('v') ?? u.pathname.split('/').pop() ?? '';
+    }
+    catch {
+        return '';
+    }
+}
+//# sourceMappingURL=youtube-extractor.js.map

package/packages/core/dist/intelligence/zettelkasten.d.ts

@@ -0,0 +1,59 @@
+export interface FrontmatterEntry {
+    filePath: string;
+    title: string;
+    id?: string;
+    type?: string;
+    tags: string[];
+    summary?: string;
+    connections: string[];
+    archived?: boolean;
+    created?: string;
+    wordCount: number;
+}
+/**
+ * Vault의 모든 .md 파일에서 프론트메터만 추출 (본문 미읽기 → 토큰 절감).
+ * 40만 단어를 수백 줄로 압축.
+ */
+export declare function scanFrontmatter(vaultPath: string, options?: {
+    includeArchived?: boolean;
+}): FrontmatterEntry[];
+/**
+ * 기존 인덱스 코드를 분석하여 다음 사용 가능한 코드를 생성.
+ * 패턴: 1A → 1B, 1A → 1A1, 1A1 → 1A1a
+ */
+export declare function generateNextIndexCode(existingCodes: string[], parentCode?: string): string;
+/**
+ * 프론트메터에 인덱스 코드가 없는 노트에 자동 부여.
+ */
+export declare function assignIndexCodes(entries: FrontmatterEntry[]): Map<string, string>;
+/**
+ * raw/ 폴더에서 archive 플래그가 없는 파일만 반환 (인박스 제로).
+ */
+export declare function getInboxItems(vaultPath: string, rawDir?: string): FrontmatterEntry[];
+/**
+ * 파일에 archive: true 플래그 추가.
+ */
+export declare function archiveFile(fullPath: string, vaultPath?: string): void;
+/**
+ * 원자성 검증: 하나의 메모에 여러 주제가 섞여있는지 감지.
+ * - heading 3개 이상 → 분할 후보
+ * - 1500단어 초과 → 분할 후보
+ */
+export declare function checkAtomicity(entries: FrontmatterEntry[], vaultPath: string): Array<{
+    filePath: string;
+    title: string;
+    reason: string;
+    headingCount?: number;
+    wordCount: number;
+}>;
+/**
+ * 고아 노트 (연결 0개) + 끊긴 링크 탐지.
+ */
+export declare function detectOrphansAndBrokenLinks(entries: FrontmatterEntry[]): {
+    orphans: FrontmatterEntry[];
+    brokenLinks: Array<{
+        filePath: string;
+        brokenLink: string;
+    }>;
+};
+//# sourceMappingURL=zettelkasten.d.ts.map

package/packages/core/dist/intelligence/zettelkasten.js

@@ -0,0 +1,234 @@
+// Zettelkasten System — 프론트메터 스캔 + 인덱스 코드 + 인박스 제로 + 원자성 검증
+// Inspired by Luhmann + Karpathy "Self-Compiling Zettelkasten"
+import { readdirSync, readFileSync, writeFileSync, existsSync, statSync } from 'node:fs';
+import { join, resolve, extname } from 'node:path';
+/**
+ * Vault의 모든 .md 파일에서 프론트메터만 추출 (본문 미읽기 → 토큰 절감).
+ * 40만 단어를 수백 줄로 압축.
+ */
+export function scanFrontmatter(vaultPath, options) {
+    const entries = [];
+    const includeArchived = options?.includeArchived ?? false;
+    function walkDir(dir, rel) {
+        if (!existsSync(dir))
+            return;
+        for (const name of readdirSync(dir)) {
+            if (name.startsWith('.') || name === 'node_modules')
+                continue;
+            const full = join(dir, name);
+            const relPath = rel ? `${rel}/${name}` : name;
+            if (statSync(full).isDirectory()) {
+                walkDir(full, relPath);
+            }
+            else if (extname(name) === '.md') {
+                const entry = extractFrontmatter(full, relPath);
+                if (entry && (includeArchived || !entry.archived)) {
+                    entries.push(entry);
+                }
+            }
+        }
+    }
+    walkDir(vaultPath, '');
+    return entries;
+}
+function extractFrontmatter(fullPath, relPath) {
+    const raw = readFileSync(fullPath, 'utf-8');
+    // Quick word count without full parse
+    const wordCount = raw.split(/\s+/).length;
+    // Parse YAML frontmatter
+    const fmMatch = raw.match(/^---\n([\s\S]*?)\n---/);
+    if (!fmMatch) {
+        // No frontmatter — extract title from first heading
+        const titleMatch = raw.match(/^#\s+(.+)$/m);
+        return {
+            filePath: relPath,
+            title: titleMatch?.[1] ?? relPath.replace(/\.md$/, ''),
+            tags: [],
+            connections: [],
+            wordCount,
+        };
+    }
+    const fm = fmMatch[1];
+    const get = (key) => {
+        const m = fm.match(new RegExp(`^${key}:\\s*["']?(.+?)["']?\\s*$`, 'm'));
+        return m?.[1];
+    };
+    const getArray = (key) => {
+        const m = fm.match(new RegExp(`^${key}:\\s*\\[([^\\]]*)\\]`, 'm'));
+        if (m)
+            return m[1].split(',').map(s => s.trim().replace(/["']/g, '')).filter(Boolean);
+        return [];
+    };
+    const getBool = (key) => {
+        const v = get(key);
+        if (v === 'true')
+            return true;
+        if (v === 'false')
+            return false;
+        return undefined;
+    };
+    // Extract [[backlinks]] from content (quick scan, first 500 chars)
+    const linkSection = raw.substring(0, Math.min(raw.length, 2000));
+    const links = [...linkSection.matchAll(/\[\[([^\]|]+)(?:\|[^\]]+)?\]\]/g)].map(m => m[1]);
+    return {
+        filePath: relPath,
+        title: get('title') ?? relPath.replace(/\.md$/, ''),
+        id: get('id') ?? get('zettel_id'),
+        type: get('type') ?? get('note_type'),
+        tags: getArray('tags'),
+        summary: get('summary') ?? get('description'),
+        connections: links,
+        archived: getBool('archived') ?? getBool('archive'),
+        created: get('created') ?? get('date'),
+        wordCount,
+    };
+}
+// ─── Luhmann Index Code ───
+/**
+ * 기존 인덱스 코드를 분석하여 다음 사용 가능한 코드를 생성.
+ * 패턴: 1A → 1B, 1A → 1A1, 1A1 → 1A1a
+ */
+export function generateNextIndexCode(existingCodes, parentCode) {
+    if (existingCodes.length === 0 && !parentCode)
+        return '1A';
+    if (parentCode) {
+        // 하위 분기: parentCode의 자식 중 마지막 번호 + 1
+        const children = existingCodes.filter(c => c.startsWith(parentCode) && c.length > parentCode.length);
+        if (children.length === 0) {
+            // 첫 자식: 숫자 끝이면 알파벳 추가, 알파벳 끝이면 숫자 추가
+            const lastChar = parentCode[parentCode.length - 1];
+            return /[a-zA-Z]/.test(lastChar) ? `${parentCode}1` : `${parentCode}a`;
+        }
+        // 마지막 자식의 다음
+        const sorted = children.sort();
+        const last = sorted[sorted.length - 1];
+        return incrementCode(last);
+    }
+    // 최상위: 마지막 코드의 다음
+    const topLevel = existingCodes.filter(c => /^[0-9]+[A-Z]$/.test(c)).sort();
+    if (topLevel.length === 0)
+        return '1A';
+    return incrementCode(topLevel[topLevel.length - 1]);
+}
+function incrementCode(code) {
+    const lastChar = code[code.length - 1];
+    const prefix = code.slice(0, -1);
+    if (/[0-9]/.test(lastChar)) {
+        return prefix + String(parseInt(lastChar) + 1);
+    }
+    if (/[a-z]/.test(lastChar)) {
+        return prefix + String.fromCharCode(lastChar.charCodeAt(0) + 1);
+    }
+    if (/[A-Z]/.test(lastChar)) {
+        return prefix + String.fromCharCode(lastChar.charCodeAt(0) + 1);
+    }
+    return code + '1';
+}
+/**
+ * 프론트메터에 인덱스 코드가 없는 노트에 자동 부여.
+ */
+export function assignIndexCodes(entries) {
+    const assignments = new Map(); // filePath → indexCode
+    const existingCodes = entries.filter(e => e.id).map(e => e.id);
+    for (const entry of entries) {
+        if (entry.id)
+            continue; // 이미 있음
+        // 같은 태그를 가진 노트의 인덱스 코드를 찾아 하위로 분기
+        const sibling = entries.find(e => e.id && e.tags.some(t => entry.tags.includes(t)));
+        const newCode = generateNextIndexCode([...existingCodes, ...assignments.values()], sibling?.id);
+        assignments.set(entry.filePath, newCode);
+    }
+    return assignments;
+}
+// ─── Inbox Zero (Archive) ───
+/**
+ * raw/ 폴더에서 archive 플래그가 없는 파일만 반환 (인박스 제로).
+ */
+export function getInboxItems(vaultPath, rawDir = 'raw') {
+    const rawPath = resolve(vaultPath, rawDir);
+    return scanFrontmatter(rawPath, { includeArchived: false });
+}
+/**
+ * 파일에 archive: true 플래그 추가.
+ */
+export function archiveFile(fullPath, vaultPath) {
+    // Path traversal 방지
+    const resolved = resolve(fullPath);
+    if (vaultPath && !resolved.startsWith(resolve(vaultPath))) {
+        throw new Error('Path traversal detected: file outside vault');
+    }
+    if (!existsSync(resolved))
+        throw new Error(`File not found: ${fullPath}`);
+    const content = readFileSync(resolved, 'utf-8');
+    if (content.startsWith('---\n')) {
+        const updated = content.replace('---\n', '---\narchived: true\n');
+        writeFileSync(resolved, updated, 'utf-8');
+    }
+    else {
+        writeFileSync(resolved, `---\narchived: true\n---\n\n${content}`, 'utf-8');
+    }
+}
+// ─── Atomicity Check ───
+/**
+ * 원자성 검증: 하나의 메모에 여러 주제가 섞여있는지 감지.
+ * - heading 3개 이상 → 분할 후보
+ * - 1500단어 초과 → 분할 후보
+ */
+export function checkAtomicity(entries, vaultPath) {
+    const violations = [];
+    for (const entry of entries) {
+        // 단어 수 검사
+        if (entry.wordCount > 1500) {
+            violations.push({
+                filePath: entry.filePath,
+                title: entry.title,
+                reason: `Too long (${entry.wordCount} words). Consider splitting into smaller atomic notes.`,
+                wordCount: entry.wordCount,
+            });
+            continue;
+        }
+        // Heading 수 검사 (프론트메터 이후)
+        const fullPath = resolve(vaultPath, entry.filePath);
+        if (!existsSync(fullPath))
+            continue;
+        const content = readFileSync(fullPath, 'utf-8');
+        const headings = content.match(/^##\s+.+$/gm) ?? [];
+        if (headings.length >= 4) {
+            violations.push({
+                filePath: entry.filePath,
+                title: entry.title,
+                reason: `Multiple topics (${headings.length} sections). Each heading could be its own note.`,
+                headingCount: headings.length,
+                wordCount: entry.wordCount,
+            });
+        }
+    }
+    return violations;
+}
+// ─── Orphan & Broken Link Detection ───
+/**
+ * 고아 노트 (연결 0개) + 끊긴 링크 탐지.
+ */
+export function detectOrphansAndBrokenLinks(entries) {
+    const titleSet = new Set(entries.map(e => e.title));
+    const fileSet = new Set(entries.map(e => e.filePath.replace(/\.md$/, '')));
+    // 고아: 어디서도 참조되지 않고 자기도 참조 안 하는 노트
+    const referenced = new Set();
+    for (const e of entries) {
+        for (const conn of e.connections) {
+            referenced.add(conn);
+        }
+    }
+    const orphans = entries.filter(e => e.connections.length === 0 && !referenced.has(e.title));
+    // 끊긴 링크: [[X]]가 있는데 X 노트가 없음
+    const brokenLinks = [];
+    for (const e of entries) {
+        for (const conn of e.connections) {
+            if (!titleSet.has(conn) && !fileSet.has(conn)) {
+                brokenLinks.push({ filePath: e.filePath, brokenLink: conn });
+            }
+        }
+    }
+    return { orphans, brokenLinks };
+}
+//# sourceMappingURL=zettelkasten.js.map

package/packages/core/dist/mcp/server.d.ts

@@ -1,10 +1,12 @@
 import { Server } from '@modelcontextprotocol/sdk/server/index.js';
 import type { VectorStore } from '../store/types.js';
 import type { SearchEngine } from '../search/index.js';
+import type { Embedder } from '../indexer/embedder.js';
 import type { DecayEngine } from '../intelligence/decay-engine.js';
 export interface McpServerOptions {
     store: VectorStore;
     searchEngine: SearchEngine;
+    embedder?: Embedder;
     vaultPath?: string;
     decayEngine?: DecayEngine;
 }

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

@@ -17,12 +17,16 @@ import { createLearningPathTool } from './tools/learning-path.js';
 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 { createAgenticGraphTools } from './tools/agentic-graph.js';
 export function createMcpServer(options) {
-    const { store, searchEngine, vaultPath = '', decayEngine } = options;
+    const { store, searchEngine, embedder, vaultPath = '', decayEngine } = options;
     const learningPathTool = createLearningPathTool(store);
     const detectGapsTool = createDetectGapsTool(store);
     const getEvolutionTool = createGetEvolutionTool(store);
     const linkCodeTool = createLinkCodeTool(searchEngine);
+    const askTool = createAskTool(searchEngine, vaultPath);
+    const agenticTools = embedder ? createAgenticGraphTools(store, embedder, vaultPath) : [];
     const server = new Server({ name: 'stellavault', version: '0.2.0' }, { capabilities: { tools: {} } });
     // List tools
     server.setRequestHandler(ListToolsRequestSchema, async () => ({
@@ -35,6 +39,8 @@ export function createMcpServer(options) {
             { name: detectGapsTool.name, description: detectGapsTool.description, inputSchema: detectGapsTool.inputSchema },
             { 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 },
+            ...agenticTools.map(t => ({ name: t.name, description: t.description, inputSchema: t.inputSchema })),
         ],
     }));
     // Call tool
@@ -111,7 +117,18 @@ export function createMcpServer(options) {
                 case 'link-code':
                     result = await linkCodeTool.handler(args);
                     return result;
+                case 'ask':
+                    result = await askTool.handler(args);
+                    return result;
                 default:
+                    {
+                        // Agentic graph tools (create-knowledge-node, create-knowledge-link)
+                        const agenticTool = agenticTools.find(t => t.name === name);
+                        if (agenticTool) {
+                            result = await agenticTool.handler(args);
+                            return result;
+                        }
+                    }
                     return { content: [{ type: 'text', text: `Unknown tool: ${name}` }], isError: true };
             }
             return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };