stellavault 0.2.0 → 0.3.0

package/packages/core/dist/intelligence/gap-detector.js

@@ -0,0 +1,78 @@
+// Design Ref: F01 — 지식 갭 탐지기
+// 클러스터 간 브릿지 노드 부족 영역 식별
+/**
+ * 그래프 데이터에서 지식 갭을 탐지.
+ * - 클러스터 간 연결이 약한 영역
+ * - 고립된 노드 (연결 0~1개)
+ */
+export async function detectKnowledgeGaps(store, graphData) {
+    const docs = await store.getAllDocuments();
+    const embeddings = await store.getDocumentEmbeddings();
+    // 그래프 데이터가 없으면 간단히 계산
+    if (!graphData) {
+        const { buildGraphData } = await import('../api/graph-data.js');
+        graphData = await buildGraphData(store);
+    }
+    const { nodes, edges, clusters } = graphData;
+    // 1. 클러스터 간 연결 수 매트릭스
+    const clusterEdges = new Map();
+    for (const edge of edges) {
+        const nodeA = nodes.find((n) => n.id === edge.source);
+        const nodeB = nodes.find((n) => n.id === edge.target);
+        if (!nodeA || !nodeB || nodeA.clusterId === nodeB.clusterId)
+            continue;
+        const key = [
+            Math.min(nodeA.clusterId, nodeB.clusterId),
+            Math.max(nodeA.clusterId, nodeB.clusterId),
+        ].join('-');
+        clusterEdges.set(key, (clusterEdges.get(key) ?? 0) + 1);
+    }
+    // 2. 갭 식별 (클러스터 쌍 중 연결이 적은 것)
+    const gaps = [];
+    const clusterLabels = new Map(clusters.map((c) => [c.id, c.label]));
+    for (let i = 0; i < clusters.length; i++) {
+        for (let j = i + 1; j < clusters.length; j++) {
+            const key = `${Math.min(clusters[i].id, clusters[j].id)}-${Math.max(clusters[i].id, clusters[j].id)}`;
+            const bridgeCount = clusterEdges.get(key) ?? 0;
+            // 연결이 3개 미만이면 갭
+            if (bridgeCount < 3) {
+                const labelA = clusterLabels.get(clusters[i].id) ?? `Cluster ${clusters[i].id}`;
+                const labelB = clusterLabels.get(clusters[j].id) ?? `Cluster ${clusters[j].id}`;
+                // 제안 주제: 두 클러스터 이름에서 추출
+                const nameA = labelA.replace(/\s*\(\d+\)$/, '');
+                const nameB = labelB.replace(/\s*\(\d+\)$/, '');
+                gaps.push({
+                    clusterA: labelA,
+                    clusterB: labelB,
+                    bridgeCount,
+                    suggestedTopic: `${nameA} + ${nameB} 연결 지식`,
+                    severity: bridgeCount === 0 ? 'high' : bridgeCount < 2 ? 'medium' : 'low',
+                });
+            }
+        }
+    }
+    // 3. 고립 노드 (연결 1개 이하)
+    const connectionCounts = new Map();
+    for (const edge of edges) {
+        connectionCounts.set(edge.source, (connectionCounts.get(edge.source) ?? 0) + 1);
+        connectionCounts.set(edge.target, (connectionCounts.get(edge.target) ?? 0) + 1);
+    }
+    const isolatedNodes = nodes
+        .filter((n) => (connectionCounts.get(n.id) ?? 0) <= 1)
+        .map((n) => ({
+        id: n.id,
+        title: n.label,
+        connections: connectionCounts.get(n.id) ?? 0,
+    }))
+        .slice(0, 20);
+    return {
+        totalClusters: clusters.length,
+        totalGaps: gaps.filter(g => g.severity !== 'low').length,
+        gaps: gaps.sort((a, b) => {
+            const sev = { high: 0, medium: 1, low: 2 };
+            return sev[a.severity] - sev[b.severity];
+        }).slice(0, 15),
+        isolatedNodes,
+    };
+}
+//# sourceMappingURL=gap-detector.js.map

package/packages/core/dist/intelligence/learning-path.d.ts

@@ -0,0 +1,31 @@
+import type { DecayReport } from './types.js';
+export interface LearningItem {
+    documentId: string;
+    title: string;
+    reason: string;
+    priority: 'critical' | 'important' | 'suggested';
+    score: number;
+    category: 'review' | 'explore' | 'bridge';
+}
+export interface LearningPath {
+    items: LearningItem[];
+    summary: {
+        reviewCount: number;
+        exploreCount: number;
+        bridgeCount: number;
+        estimatedMinutes: number;
+    };
+    generatedAt: string;
+}
+export interface LearningPathInput {
+    decayReport: DecayReport;
+    gaps?: Array<{
+        clusterA: string;
+        clusterB: string;
+        severity: string;
+        suggestedTopic: string;
+    }>;
+    recentSearches?: string[];
+}
+export declare function generateLearningPath(input: LearningPathInput, limit?: number): LearningPath;
+//# sourceMappingURL=learning-path.d.ts.map

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