stellavault 0.1.0 → 0.2.1

package/packages/core/dist/intelligence/learning-path.js

@@ -0,0 +1,53 @@
+// AI Learning Path Generator (F-A11)
+// Analyzes decay + gaps + relationships to recommend what to review/learn next
+export function generateLearningPath(input, limit = 15) {
+    const items = [];
+    // 1. Review: decaying notes (highest priority)
+    if (input.decayReport.topDecaying) {
+        for (const d of input.decayReport.topDecaying) {
+            const r = d.retrievability ?? 0;
+            const urgency = (1 - r) * 100;
+            items.push({
+                documentId: d.documentId,
+                title: d.title,
+                reason: r < 0.3
+                    ? `Critical: ${Math.round(r * 100)}% retrievability, ${d.daysSinceAccess}d since last access`
+                    : `Fading: ${Math.round(r * 100)}% retrievability, review to strengthen memory`,
+                priority: r < 0.3 ? 'critical' : r < 0.5 ? 'important' : 'suggested',
+                score: Math.round(urgency),
+                category: 'review',
+            });
+        }
+    }
+    // 2. Bridge: knowledge gaps
+    if (input.gaps) {
+        for (const gap of input.gaps) {
+            const severityScore = gap.severity === 'high' ? 80 : gap.severity === 'medium' ? 60 : 40;
+            items.push({
+                documentId: '',
+                title: gap.suggestedTopic || `${gap.clusterA} × ${gap.clusterB}`,
+                reason: `Gap between "${gap.clusterA}" and "${gap.clusterB}" — creating a bridge note strengthens your knowledge network`,
+                priority: gap.severity === 'high' ? 'important' : 'suggested',
+                score: severityScore,
+                category: 'bridge',
+            });
+        }
+    }
+    // Sort by score descending
+    items.sort((a, b) => b.score - a.score);
+    const selected = items.slice(0, limit);
+    const reviewCount = selected.filter(i => i.category === 'review').length;
+    const exploreCount = selected.filter(i => i.category === 'explore').length;
+    const bridgeCount = selected.filter(i => i.category === 'bridge').length;
+    return {
+        items: selected,
+        summary: {
+            reviewCount,
+            exploreCount,
+            bridgeCount,
+            estimatedMinutes: reviewCount * 3 + exploreCount * 5 + bridgeCount * 8,
+        },
+        generatedAt: new Date().toISOString(),
+    };
+}
+//# sourceMappingURL=learning-path.js.map

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

@@ -0,0 +1,31 @@
+import type { DecayReport } from './types.js';
+export interface NotificationConfig {
+    decay: {
+        enabled: boolean;
+        criticalThreshold: number;
+        warningThreshold: number;
+    };
+    gaps: {
+        enabled: boolean;
+        minSeverity: 'low' | 'medium' | 'high';
+    };
+    digest: {
+        enabled: boolean;
+        frequency: 'daily' | 'weekly' | 'off';
+    };
+}
+export interface Notification {
+    id: string;
+    type: 'decay_critical' | 'decay_warning' | 'gap_detected' | 'digest';
+    title: string;
+    message: string;
+    timestamp: string;
+    priority: 'high' | 'medium' | 'low';
+    data?: Record<string, unknown>;
+}
+export declare function checkNotifications(decayReport: DecayReport, gaps: Array<{
+    severity: string;
+    clusterA: string;
+    clusterB: string;
+}>, config?: Partial<NotificationConfig>): Notification[];
+//# sourceMappingURL=notifications.d.ts.map

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

@@ -0,0 +1,65 @@
+// Notification Center (F-A05)
+// Configurable alerts for decay thresholds, gap detection, weekly digest
+const DEFAULT_CONFIG = {
+    decay: { enabled: true, criticalThreshold: 0.3, warningThreshold: 0.5 },
+    gaps: { enabled: true, minSeverity: 'medium' },
+    digest: { enabled: true, frequency: 'weekly' },
+};
+export function checkNotifications(decayReport, gaps, config = {}) {
+    const cfg = {
+        decay: { ...DEFAULT_CONFIG.decay, ...config.decay },
+        gaps: { ...DEFAULT_CONFIG.gaps, ...config.gaps },
+        digest: { ...DEFAULT_CONFIG.digest, ...config.digest },
+    };
+    const notifications = [];
+    const now = new Date().toISOString();
+    // Decay alerts
+    if (cfg.decay.enabled && decayReport.topDecaying) {
+        const criticals = decayReport.topDecaying.filter(d => d.retrievability < cfg.decay.criticalThreshold);
+        const warnings = decayReport.topDecaying.filter(d => d.retrievability >= cfg.decay.criticalThreshold && d.retrievability < cfg.decay.warningThreshold);
+        if (criticals.length > 0) {
+            notifications.push({
+                id: `decay-critical-${Date.now()}`,
+                type: 'decay_critical',
+                title: `${criticals.length} notes critically fading`,
+                message: criticals.slice(0, 3).map(d => `"${d.title}" (${Math.round(d.retrievability * 100)}%)`).join(', '),
+                timestamp: now,
+                priority: 'high',
+                data: { count: criticals.length, notes: criticals.slice(0, 5).map(d => d.title) },
+            });
+        }
+        if (warnings.length > 0) {
+            notifications.push({
+                id: `decay-warning-${Date.now()}`,
+                type: 'decay_warning',
+                title: `${warnings.length} notes starting to fade`,
+                message: `Average retrievability: ${Math.round(decayReport.averageR * 100)}%`,
+                timestamp: now,
+                priority: 'medium',
+                data: { count: warnings.length },
+            });
+        }
+    }
+    // Gap alerts
+    if (cfg.gaps.enabled) {
+        const severityOrder = { high: 3, medium: 2, low: 1 };
+        const minLevel = severityOrder[cfg.gaps.minSeverity] ?? 2;
+        const significantGaps = gaps.filter(g => (severityOrder[g.severity] ?? 0) >= minLevel);
+        if (significantGaps.length > 0) {
+            notifications.push({
+                id: `gap-${Date.now()}`,
+                type: 'gap_detected',
+                title: `${significantGaps.length} knowledge gaps detected`,
+                message: significantGaps.slice(0, 2).map(g => `${g.clusterA} ↔ ${g.clusterB}`).join(', '),
+                timestamp: now,
+                priority: significantGaps.some(g => g.severity === 'high') ? 'high' : 'medium',
+                data: { count: significantGaps.length },
+            });
+        }
+    }
+    return notifications.sort((a, b) => {
+        const p = { high: 3, medium: 2, low: 1 };
+        return (p[b.priority] ?? 0) - (p[a.priority] ?? 0);
+    });
+}
+//# sourceMappingURL=notifications.js.map

package/packages/core/dist/intelligence/predictive-gaps.d.ts

@@ -0,0 +1,14 @@
+import type { VectorStore } from '../store/types.js';
+export interface PredictedGap {
+    topic: string;
+    reason: string;
+    confidence: number;
+    relatedTopics: string[];
+    category: 'adjacent' | 'bridging' | 'deepening';
+}
+/**
+ * Analyze graph topology to predict knowledge worth acquiring.
+ * Uses degree centrality, cluster density, and tag co-occurrence.
+ */
+export declare function predictKnowledgeGaps(store: VectorStore, limit?: number): Promise<PredictedGap[]>;
+//# sourceMappingURL=predictive-gaps.d.ts.map

package/packages/core/dist/intelligence/predictive-gaps.js

@@ -0,0 +1,74 @@
+// Predictive Gap Analysis (F-A14)
+// Based on graph topology, predict knowledge areas worth exploring
+/**
+ * Analyze graph topology to predict knowledge worth acquiring.
+ * Uses degree centrality, cluster density, and tag co-occurrence.
+ */
+export async function predictKnowledgeGaps(store, limit = 10) {
+    const docs = await store.getAllDocuments();
+    const topics = await store.getTopics();
+    if (docs.length < 10)
+        return [];
+    const predictions = [];
+    // 1. Find isolated tags (topics that appear rarely and could be expanded)
+    const topicCounts = new Map(topics.map(t => [t.topic, t.count]));
+    const avgCount = topics.reduce((s, t) => s + t.count, 0) / (topics.length || 1);
+    // Tags that appear 1-2 times — potential deepening opportunities
+    const sparseTopics = topics.filter(t => t.count <= 2 && t.count > 0);
+    for (const t of sparseTopics.slice(0, 5)) {
+        predictions.push({
+            topic: t.topic,
+            reason: `Only ${t.count} note(s) on "${t.topic}" — deepening this area would strengthen your knowledge network`,
+            confidence: 0.6,
+            relatedTopics: findCoOccurring(t.topic, docs),
+            category: 'deepening',
+        });
+    }
+    // 2. Find tag pairs that never co-occur but are both frequent
+    const frequentTopics = topics.filter(t => t.count >= avgCount).slice(0, 20);
+    const coOccurrence = new Map();
+    for (const doc of docs) {
+        for (const tagA of doc.tags) {
+            if (!coOccurrence.has(tagA))
+                coOccurrence.set(tagA, new Set());
+            for (const tagB of doc.tags) {
+                if (tagA !== tagB)
+                    coOccurrence.get(tagA).add(tagB);
+            }
+        }
+    }
+    for (let i = 0; i < frequentTopics.length; i++) {
+        for (let j = i + 1; j < frequentTopics.length; j++) {
+            const a = frequentTopics[i].topic;
+            const b = frequentTopics[j].topic;
+            const aCoOccurs = coOccurrence.get(a) ?? new Set();
+            if (!aCoOccurs.has(b)) {
+                predictions.push({
+                    topic: `${a} × ${b}`,
+                    reason: `"${a}" (${frequentTopics[i].count} notes) and "${b}" (${frequentTopics[j].count} notes) are both well-known but never connected — bridging them could reveal insights`,
+                    confidence: 0.7,
+                    relatedTopics: [a, b],
+                    category: 'bridging',
+                });
+            }
+        }
+    }
+    // 3. Adjacent topics — topics that co-occur with many of your topics but you don't have
+    // (This would ideally use external knowledge, but we approximate with tag patterns)
+    return predictions
+        .sort((a, b) => b.confidence - a.confidence)
+        .slice(0, limit);
+}
+function findCoOccurring(topic, docs) {
+    const coTopics = new Map();
+    for (const doc of docs) {
+        if (doc.tags.includes(topic)) {
+            for (const t of doc.tags) {
+                if (t !== topic)
+                    coTopics.set(t, (coTopics.get(t) ?? 0) + 1);
+            }
+        }
+    }
+    return [...coTopics.entries()].sort((a, b) => b[1] - a[1]).slice(0, 5).map(([t]) => t);
+}
+//# sourceMappingURL=predictive-gaps.js.map

package/packages/core/dist/intelligence/semantic-versioning.d.ts

@@ -0,0 +1,37 @@
+export interface SemanticVersion {
+    documentId: string;
+    timestamp: string;
+    embeddingHash: string;
+    drift: number;
+}
+export interface SemanticChangelog {
+    documentId: string;
+    title: string;
+    versions: SemanticVersion[];
+    totalDrift: number;
+    stability: number;
+}
+/**
+ * Compute semantic drift between two embedding vectors.
+ * Returns cosine distance (0 = identical, 1 = orthogonal, 2 = opposite)
+ */
+export declare function computeSemanticDrift(vecA: number[], vecB: number[]): number;
+/**
+ * Hash an embedding vector for quick comparison
+ */
+export declare function hashEmbedding(vec: number[]): string;
+/**
+ * Analyze semantic stability of a document given its embedding history.
+ * In practice, we compare current embedding vs initial embedding to measure total drift.
+ */
+export declare function analyzeSemanticStability(currentVec: number[], title: string, documentId: string): SemanticChangelog;
+/**
+ * Compare two sets of embeddings to find documents with the most semantic drift.
+ * Useful for "what changed the most since last index?"
+ */
+export declare function findMostDrifted(previousEmbeddings: Map<string, number[]>, currentEmbeddings: Map<string, number[]>, titles: Map<string, string>, limit?: number): Array<{
+    documentId: string;
+    title: string;
+    drift: number;
+}>;
+//# sourceMappingURL=semantic-versioning.d.ts.map

package/packages/core/dist/intelligence/semantic-versioning.js

@@ -0,0 +1,68 @@
+// Knowledge Semantic Versioning (F-A13)
+// Track how a note's MEANING changes over time via embedding drift
+/**
+ * Compute semantic drift between two embedding vectors.
+ * Returns cosine distance (0 = identical, 1 = orthogonal, 2 = opposite)
+ */
+export function computeSemanticDrift(vecA, vecB) {
+    if (vecA.length !== vecB.length || vecA.length === 0)
+        return 0;
+    let dot = 0, na = 0, nb = 0;
+    for (let i = 0; i < vecA.length; i++) {
+        dot += vecA[i] * vecB[i];
+        na += vecA[i] * vecA[i];
+        nb += vecB[i] * vecB[i];
+    }
+    const denom = Math.sqrt(na) * Math.sqrt(nb);
+    const similarity = denom === 0 ? 0 : dot / denom;
+    return 1 - similarity; // cosine distance
+}
+/**
+ * Hash an embedding vector for quick comparison
+ */
+export function hashEmbedding(vec) {
+    let hash = 0;
+    for (let i = 0; i < Math.min(vec.length, 50); i++) {
+        hash = ((hash << 5) - hash + Math.round(vec[i] * 10000)) | 0;
+    }
+    return Math.abs(hash).toString(36).slice(0, 8);
+}
+/**
+ * Analyze semantic stability of a document given its embedding history.
+ * In practice, we compare current embedding vs initial embedding to measure total drift.
+ */
+export function analyzeSemanticStability(currentVec, title, documentId) {
+    // Single-point analysis (no history yet — foundation for future multi-version tracking)
+    const now = new Date().toISOString();
+    const hash = hashEmbedding(currentVec);
+    return {
+        documentId,
+        title,
+        versions: [{
+                documentId,
+                timestamp: now,
+                embeddingHash: hash,
+                drift: 0,
+            }],
+        totalDrift: 0,
+        stability: 1.0,
+    };
+}
+/**
+ * Compare two sets of embeddings to find documents with the most semantic drift.
+ * Useful for "what changed the most since last index?"
+ */
+export function findMostDrifted(previousEmbeddings, currentEmbeddings, titles, limit = 10) {
+    const drifts = [];
+    for (const [docId, currentVec] of currentEmbeddings) {
+        const prevVec = previousEmbeddings.get(docId);
+        if (!prevVec)
+            continue;
+        const drift = computeSemanticDrift(prevVec, currentVec);
+        if (drift > 0.01) { // ignore trivial changes
+            drifts.push({ documentId: docId, title: titles.get(docId) ?? docId, drift: Math.round(drift * 1000) / 1000 });
+        }
+    }
+    return drifts.sort((a, b) => b.drift - a.drift).slice(0, limit);
+}
+//# sourceMappingURL=semantic-versioning.js.map

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

@@ -0,0 +1,28 @@
+export interface DecayState {
+    documentId: string;
+    stability: number;
+    difficulty: number;
+    lastAccess: string;
+    retrievability: number;
+}
+export interface AccessEvent {
+    documentId: string;
+    type: 'view' | 'search' | 'mcp_query';
+    timestamp: string;
+}
+export interface DecayReport {
+    totalDocuments: number;
+    decayingCount: number;
+    criticalCount: number;
+    averageR: number;
+    topDecaying: Array<DecayState & {
+        title: string;
+        daysSinceAccess: number;
+    }>;
+    clusterHealth: Array<{
+        label: string;
+        avgR: number;
+        count: number;
+    }>;
+}
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1,3 @@
+// Design Ref: §2.2 — FSRS 감쇠 타입 정의
+export {};
+//# sourceMappingURL=types.js.map

package/packages/core/dist/mcp/custom-tools.d.ts

@@ -0,0 +1,29 @@
+import type { SearchEngine } from '../search/index.js';
+export interface CustomToolDef {
+    name: string;
+    description: string;
+    query_template: string;
+    output_format?: 'full' | 'titles' | 'snippets';
+    limit?: number;
+    filter_tags?: string[];
+}
+export interface LoadedCustomTool {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: 'object';
+        properties: Record<string, {
+            type: string;
+            description: string;
+        }>;
+        required?: string[];
+    };
+    handler: (args: Record<string, unknown>) => Promise<{
+        content: Array<{
+            type: 'text';
+            text: string;
+        }>;
+    }>;
+}
+export declare function loadCustomTools(toolsDir: string, searchEngine: SearchEngine): LoadedCustomTool[];
+//# sourceMappingURL=custom-tools.d.ts.map

package/packages/core/dist/mcp/custom-tools.js

@@ -0,0 +1,70 @@
+// Custom MCP Tool Builder (F-A16)
+// Load YAML/JSON tool definitions without coding
+import { readFileSync, existsSync, readdirSync } from 'node:fs';
+import { join } from 'node:path';
+export function loadCustomTools(toolsDir, searchEngine) {
+    if (!existsSync(toolsDir))
+        return [];
+    const tools = [];
+    const files = readdirSync(toolsDir).filter(f => f.endsWith('.json') || f.endsWith('.yaml') || f.endsWith('.yml'));
+    for (const file of files) {
+        try {
+            const raw = readFileSync(join(toolsDir, file), 'utf-8');
+            let def;
+            if (file.endsWith('.json')) {
+                def = JSON.parse(raw);
+            }
+            else {
+                // Simple YAML parser for basic key:value format
+                def = parseSimpleYaml(raw);
+            }
+            if (!def.name || !def.description || !def.query_template)
+                continue;
+            // Extract template variables ({{var}})
+            const vars = [...def.query_template.matchAll(/\{\{(\w+)\}\}/g)].map(m => m[1]);
+            tools.push({
+                name: def.name,
+                description: def.description,
+                inputSchema: {
+                    type: 'object',
+                    properties: Object.fromEntries(vars.map(v => [v, { type: 'string', description: `Value for ${v}` }])),
+                    required: vars,
+                },
+                handler: async (args) => {
+                    let query = def.query_template;
+                    for (const [key, val] of Object.entries(args)) {
+                        query = query.replace(`{{${key}}}`, String(val));
+                    }
+                    const results = await searchEngine.search({ query, limit: def.limit ?? 5 });
+                    const format = def.output_format ?? 'snippets';
+                    let text;
+                    if (format === 'titles') {
+                        text = results.map(r => `- ${r.document.title}`).join('\n');
+                    }
+                    else if (format === 'full') {
+                        text = results.map(r => `## ${r.document.title}\n\n${r.document.content.slice(0, 1000)}`).join('\n\n---\n\n');
+                    }
+                    else {
+                        text = results.map(r => `**${r.document.title}** (${Math.round(r.score * 100)}%)\n${r.chunk.content.slice(0, 200)}...`).join('\n\n');
+                    }
+                    return { content: [{ type: 'text', text: text || 'No results found.' }] };
+                },
+            });
+        }
+        catch {
+            // Skip invalid tool files
+        }
+    }
+    return tools;
+}
+function parseSimpleYaml(raw) {
+    const result = {};
+    for (const line of raw.split('\n')) {
+        const match = line.match(/^(\w[\w_]*)\s*:\s*(.+)$/);
+        if (match) {
+            result[match[1]] = match[2].replace(/^["']|["']$/g, '').trim();
+        }
+    }
+    return result;
+}
+//# sourceMappingURL=custom-tools.js.map

package/packages/core/{src/mcp/index.ts → dist/mcp/index.d.ts}

@@ -1 +1,2 @@
 export { createMcpServer, type McpServerOptions } from './server.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,2 @@
+export { createMcpServer } from './server.js';
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,49 @@
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import type { VectorStore } from '../store/types.js';
+import type { SearchEngine } from '../search/index.js';
+import type { DecayEngine } from '../intelligence/decay-engine.js';
+export interface McpServerOptions {
+    store: VectorStore;
+    searchEngine: SearchEngine;
+    vaultPath?: string;
+    decayEngine?: DecayEngine;
+}
+export declare function createMcpServer(options: McpServerOptions): {
+    startStdio(): Promise<void>;
+    startHttp(port?: number): Promise<void>;
+    server: Server<{
+        method: string;
+        params?: {
+            [x: string]: unknown;
+            _meta?: {
+                [x: string]: unknown;
+                progressToken?: string | number | undefined;
+                "io.modelcontextprotocol/related-task"?: {
+                    taskId: string;
+                } | undefined;
+            } | undefined;
+        } | undefined;
+    }, {
+        method: string;
+        params?: {
+            [x: string]: unknown;
+            _meta?: {
+                [x: string]: unknown;
+                progressToken?: string | number | undefined;
+                "io.modelcontextprotocol/related-task"?: {
+                    taskId: string;
+                } | undefined;
+            } | undefined;
+        } | undefined;
+    }, {
+        [x: string]: unknown;
+        _meta?: {
+            [x: string]: unknown;
+            progressToken?: string | number | undefined;
+            "io.modelcontextprotocol/related-task"?: {
+                taskId: string;
+            } | undefined;
+        } | undefined;
+    }>;
+};
+//# sourceMappingURL=server.d.ts.map

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

@@ -0,0 +1,133 @@
+// Design Ref: §4.1 — MCP Server (stdio + SSE)
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { CallToolRequestSchema, ListToolsRequestSchema } from '@modelcontextprotocol/sdk/types.js';
+import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
+import { searchToolDef, handleSearch } from './tools/search.js';
+import { getDocumentToolDef, handleGetDocument } from './tools/get-document.js';
+import { listTopicsToolDef, handleListTopics } from './tools/list-topics.js';
+import { getRelatedToolDef, handleGetRelated } from './tools/get-related.js';
+import { generateClaudeMdToolDef, handleGenerateClaudeMd } from './tools/generate-claude-md.js';
+import { createSnapshotToolDef, loadSnapshotToolDef, handleCreateSnapshot, handleLoadSnapshot } from './tools/snapshot.js';
+import { logDecisionToolDef, findDecisionsToolDef, handleLogDecision, handleFindDecisions } from './tools/decision-journal.js';
+import { exportToolDef, handleExport } from './tools/export.js';
+import { getDecayStatusToolDef, handleGetDecayStatus } from './tools/decay.js';
+import { getMorningBriefToolDef, handleGetMorningBrief } from './tools/brief.js';
+import { createLearningPathTool } from './tools/learning-path.js';
+export function createMcpServer(options) {
+    const { store, searchEngine, vaultPath = '', decayEngine } = options;
+    const learningPathTool = createLearningPathTool(store);
+    const server = new Server({ name: 'stellavault', version: '0.2.0' }, { capabilities: { tools: {} } });
+    // List tools
+    server.setRequestHandler(ListToolsRequestSchema, async () => ({
+        tools: [
+            searchToolDef, getDocumentToolDef, listTopicsToolDef, getRelatedToolDef,
+            generateClaudeMdToolDef, createSnapshotToolDef, loadSnapshotToolDef,
+            logDecisionToolDef, findDecisionsToolDef, exportToolDef,
+            ...(decayEngine ? [getDecayStatusToolDef, getMorningBriefToolDef] : []),
+            { name: learningPathTool.name, description: learningPathTool.description, inputSchema: learningPathTool.inputSchema },
+        ],
+    }));
+    // Call tool
+    server.setRequestHandler(CallToolRequestSchema, async (request) => {
+        const { name, arguments: args } = request.params;
+        try {
+            let result;
+            switch (name) {
+                case 'search':
+                    result = await handleSearch(searchEngine, args);
+                    // MCP 검색 이벤트 기록
+                    if (decayEngine && result && typeof result === 'object' && 'results' in result) {
+                        const now = new Date().toISOString();
+                        for (const r of result.results ?? []) {
+                            if (r.documentId)
+                                decayEngine.recordAccess({ documentId: r.documentId, type: 'mcp_query', timestamp: now }).catch(() => { });
+                        }
+                    }
+                    break;
+                case 'get-document':
+                    result = await handleGetDocument(store, args);
+                    // MCP 문서 조회 이벤트 기록
+                    if (decayEngine && result && typeof result === 'object' && 'id' in result) {
+                        decayEngine.recordAccess({ documentId: result.id, type: 'mcp_query', timestamp: new Date().toISOString() }).catch(() => { });
+                    }
+                    break;
+                case 'list-topics':
+                    result = await handleListTopics(store);
+                    break;
+                case 'get-related':
+                    result = await handleGetRelated(store, searchEngine, args);
+                    break;
+                case 'generate-claude-md':
+                    result = await handleGenerateClaudeMd(searchEngine, store, args);
+                    break;
+                case 'create-snapshot':
+                    result = await handleCreateSnapshot(searchEngine, args);
+                    break;
+                case 'load-snapshot':
+                    result = await handleLoadSnapshot(args);
+                    break;
+                case 'log-decision':
+                    result = await handleLogDecision(vaultPath, args);
+                    break;
+                case 'find-decisions':
+                    result = await handleFindDecisions(vaultPath, args);
+                    break;
+                case 'export':
+                    result = await handleExport(store, args);
+                    break;
+                case 'get-decay-status':
+                    if (!decayEngine) {
+                        result = { error: 'Decay engine not available' };
+                        break;
+                    }
+                    result = await handleGetDecayStatus(decayEngine, args);
+                    break;
+                case 'get-morning-brief':
+                    if (!decayEngine) {
+                        result = { error: 'Decay engine not available' };
+                        break;
+                    }
+                    result = await handleGetMorningBrief(decayEngine, store);
+                    break;
+                case 'get-learning-path':
+                    result = await learningPathTool.handler(args);
+                    return result;
+                default:
+                    return { content: [{ type: 'text', text: `Unknown tool: ${name}` }], isError: true };
+            }
+            return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            return { content: [{ type: 'text', text: `Error: ${msg}` }], isError: true };
+        }
+    });
+    return {
+        async startStdio() {
+            const transport = new StdioServerTransport();
+            await server.connect(transport);
+        },
+        async startHttp(port = 3334) {
+            const { createServer } = await import('node:http');
+            const transport = new StreamableHTTPServerTransport({ sessionIdGenerator: () => `sv-${Date.now()}` });
+            await server.connect(transport);
+            const httpServer = createServer(async (req, res) => {
+                res.setHeader('Access-Control-Allow-Origin', '*');
+                res.setHeader('Access-Control-Allow-Methods', 'GET, POST, OPTIONS');
+                res.setHeader('Access-Control-Allow-Headers', 'Content-Type');
+                if (req.method === 'OPTIONS') {
+                    res.writeHead(204);
+                    res.end();
+                    return;
+                }
+                await transport.handleRequest(req, res);
+            });
+            httpServer.listen(port, '127.0.0.1', () => {
+                console.error(`🔌 MCP HTTP server running at http://127.0.0.1:${port}/mcp`);
+            });
+        },
+        server,
+    };
+}
+//# sourceMappingURL=server.js.map