stellavault 0.1.0 → 0.2.1

package/packages/core/src/intelligence/fsrs.ts

@@ -1,79 +0,0 @@
-// Design Ref: §1 — FSRS-6 알고리즘 (순수 함수)
-// Plan SC: SC-01 (R값 계산), SC-02 (stability 업데이트)
-
-/**
- * FSRS parameters tuned for knowledge notes (not flashcards).
- * Knowledge notes have longer natural retention than flashcards.
- */
-export const FSRS_PARAMS = {
-  initialStability: 7.0,  // 7 days for new notes
-  difficulty: 5.0,         // default difficulty (1~10)
-  // Stability growth factors
-  a: 0.4,
-  b: 0.6,
-  c: 0.2,
-  d: 1.0,
-  // Stability bonus for large/connected notes
-  sizeFactor: 0.5,        // additional days per 1000 chars
-  connectionFactor: 1.0,  // additional days per connection
-} as const;
-
-/**
- * Compute retrievability R(t) using FSRS power forgetting curve.
- * R(t) = (1 + t / (9 * S))^(-1)
- *
- * @param stabilityDays - Stability S (days until R drops to ~0.9)
- * @param elapsedDays - Days since last access
- * @returns Retrievability 0~1
- */
-export function computeRetrievability(stabilityDays: number, elapsedDays: number): number {
-  if (elapsedDays <= 0) return 1.0;
-  if (stabilityDays <= 0) return 0.0;
-  return Math.pow(1 + elapsedDays / (9 * stabilityDays), -1);
-}
-
-/**
- * Update stability after an access event (successful recall).
- * S' = S * (1 + a * D^(-b) * S^(-c) * (e^(d*(1-R)) - 1))
- *
- * @param currentS - Current stability
- * @param difficulty - Note difficulty (1~10)
- * @param currentR - Retrievability at access time
- * @returns New stability (always >= currentS)
- */
-export function updateStability(
-  currentS: number,
-  difficulty: number,
-  currentR: number,
-): number {
-  const { a, b, c, d } = FSRS_PARAMS;
-  const growth = a
-    * Math.pow(difficulty, -b)
-    * Math.pow(currentS, -c)
-    * (Math.exp(d * (1 - currentR)) - 1);
-  const newS = currentS * (1 + Math.max(0, growth));
-  // Cap at 365 days (1 year max stability)
-  return Math.min(newS, 365);
-}
-
-/**
- * Estimate initial stability based on note characteristics.
- * Longer notes and more connected notes are more stable.
- */
-export function estimateInitialStability(
-  contentLength: number,
-  connectionCount: number,
-): number {
-  const base = FSRS_PARAMS.initialStability;
-  const sizeBonus = Math.min(contentLength / 1000, 10) * FSRS_PARAMS.sizeFactor;
-  const connBonus = Math.min(connectionCount, 10) * FSRS_PARAMS.connectionFactor;
-  return base + sizeBonus + connBonus;
-}
-
-/**
- * Compute elapsed days between two ISO timestamps.
- */
-export function elapsedDays(from: string, to: string = new Date().toISOString()): number {
-  const msPerDay = 86400000;
-  return Math.max(0, (new Date(to).getTime() - new Date(from).getTime()) / msPerDay);
-}

package/packages/core/src/intelligence/gap-detector.ts

@@ -1,109 +0,0 @@
-// Design Ref: F01 — 지식 갭 탐지기
-// 클러스터 간 브릿지 노드 부족 영역 식별
-
-import type { VectorStore } from '../store/types.js';
-
-export interface KnowledgeGap {
-  clusterA: string;
-  clusterB: string;
-  bridgeCount: number;      // 연결 노드 수 (적을수록 갭)
-  suggestedTopic: string;   // 학습 추천 주제
-  severity: 'high' | 'medium' | 'low';
-}
-
-export interface GapReport {
-  totalClusters: number;
-  totalGaps: number;
-  gaps: KnowledgeGap[];
-  isolatedNodes: Array<{ id: string; title: string; connections: number }>;
-}
-
-/**
- * 그래프 데이터에서 지식 갭을 탐지.
- * - 클러스터 간 연결이 약한 영역
- * - 고립된 노드 (연결 0~1개)
- */
-export async function detectKnowledgeGaps(
-  store: VectorStore,
-  graphData?: any, // buildGraphData 결과 (없으면 직접 계산)
-): Promise<GapReport> {
-  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<string, number>();
-  for (const edge of edges) {
-    const nodeA = nodes.find((n: any) => n.id === edge.source);
-    const nodeB = nodes.find((n: any) => 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: KnowledgeGap[] = [];
-  const clusterLabels = new Map<number, string>(clusters.map((c: any) => [c.id, c.label as string]));
-
-  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<string, number>();
-  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: any) => (connectionCounts.get(n.id) ?? 0) <= 1)
-    .map((n: any) => ({
-      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,
-  };
-}

package/packages/core/src/intelligence/learning-path.ts

@@ -1,86 +0,0 @@
-// AI Learning Path Generator (F-A11)
-// Analyzes decay + gaps + relationships to recommend what to review/learn next
-
-import type { DecayReport, DecayState } from './types.js';
-
-export interface LearningItem {
-  documentId: string;
-  title: string;
-  reason: string;
-  priority: 'critical' | 'important' | 'suggested';
-  score: number; // 0-100, higher = more urgent
-  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 function generateLearningPath(input: LearningPathInput, limit = 15): LearningPath {
-  const items: LearningItem[] = [];
-
-  // 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(),
-  };
-}

package/packages/core/src/intelligence/notifications.ts

@@ -1,106 +0,0 @@
-// Notification Center (F-A05)
-// Configurable alerts for decay thresholds, gap detection, weekly digest
-
-import type { DecayReport } from './types.js';
-
-export interface NotificationConfig {
-  decay: {
-    enabled: boolean;
-    criticalThreshold: number; // R value (0-1), default 0.3
-    warningThreshold: number;  // default 0.5
-  };
-  gaps: {
-    enabled: boolean;
-    minSeverity: 'low' | 'medium' | 'high'; // default 'medium'
-  };
-  digest: {
-    enabled: boolean;
-    frequency: 'daily' | 'weekly' | 'off'; // default 'weekly'
-  };
-}
-
-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>;
-}
-
-const DEFAULT_CONFIG: NotificationConfig = {
-  decay: { enabled: true, criticalThreshold: 0.3, warningThreshold: 0.5 },
-  gaps: { enabled: true, minSeverity: 'medium' },
-  digest: { enabled: true, frequency: 'weekly' },
-};
-
-export function checkNotifications(
-  decayReport: DecayReport,
-  gaps: Array<{ severity: string; clusterA: string; clusterB: string }>,
-  config: Partial<NotificationConfig> = {},
-): Notification[] {
-  const cfg = {
-    decay: { ...DEFAULT_CONFIG.decay, ...config.decay },
-    gaps: { ...DEFAULT_CONFIG.gaps, ...config.gaps },
-    digest: { ...DEFAULT_CONFIG.digest, ...config.digest },
-  };
-  const notifications: Notification[] = [];
-  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 as keyof typeof severityOrder] ?? 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);
-  });
-}

package/packages/core/src/intelligence/predictive-gaps.ts

@@ -1,94 +0,0 @@
-// Predictive Gap Analysis (F-A14)
-// Based on graph topology, predict knowledge areas worth exploring
-
-import type { VectorStore } from '../store/types.js';
-
-export interface PredictedGap {
-  topic: string;
-  reason: string;
-  confidence: number; // 0-1
-  relatedTopics: string[];
-  category: 'adjacent' | 'bridging' | 'deepening';
-}
-
-/**
- * Analyze graph topology to predict knowledge worth acquiring.
- * Uses degree centrality, cluster density, and tag co-occurrence.
- */
-export async function predictKnowledgeGaps(
-  store: VectorStore,
-  limit = 10,
-): Promise<PredictedGap[]> {
-  const docs = await store.getAllDocuments();
-  const topics = await store.getTopics();
-
-  if (docs.length < 10) return [];
-
-  const predictions: PredictedGap[] = [];
-
-  // 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<string, Set<string>>();
-
-  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: string, docs: Array<{ tags: string[] }>): string[] {
-  const coTopics = new Map<string, number>();
-  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);
-}

package/packages/core/src/intelligence/semantic-versioning.ts

@@ -1,97 +0,0 @@
-// Knowledge Semantic Versioning (F-A13)
-// Track how a note's MEANING changes over time via embedding drift
-
-export interface SemanticVersion {
-  documentId: string;
-  timestamp: string;
-  embeddingHash: string; // first 8 chars of embedding vector hash
-  drift: number; // cosine distance from previous version (0 = identical, 2 = opposite)
-}
-
-export interface SemanticChangelog {
-  documentId: string;
-  title: string;
-  versions: SemanticVersion[];
-  totalDrift: number; // cumulative semantic drift
-  stability: number; // 0-1, how stable the meaning has been
-}
-
-/**
- * Compute semantic drift between two embedding vectors.
- * Returns cosine distance (0 = identical, 1 = orthogonal, 2 = opposite)
- */
-export function computeSemanticDrift(vecA: number[], vecB: number[]): number {
-  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: number[]): string {
-  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: number[],
-  title: string,
-  documentId: string,
-): SemanticChangelog {
-  // 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: Map<string, number[]>,
-  currentEmbeddings: Map<string, number[]>,
-  titles: Map<string, string>,
-  limit = 10,
-): Array<{ documentId: string; title: string; drift: number }> {
-  const drifts: Array<{ documentId: string; title: string; drift: number }> = [];
-
-  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);
-}

package/packages/core/src/intelligence/types.ts

@@ -1,28 +0,0 @@
-// Design Ref: §2.2 — FSRS 감쇠 타입 정의
-
-export interface DecayState {
-  documentId: string;
-  stability: number;      // days until R drops to 0.9
-  difficulty: number;      // 1~10
-  lastAccess: string;      // ISO timestamp
-  retrievability: number;  // 0~1 (computed)
-}
-
-export interface AccessEvent {
-  documentId: string;
-  type: 'view' | 'search' | 'mcp_query';
-  timestamp: string;
-}
-
-export interface DecayReport {
-  totalDocuments: number;
-  decayingCount: number;   // R < 0.5
-  criticalCount: number;   // R < 0.3
-  averageR: number;
-  topDecaying: Array<DecayState & { title: string; daysSinceAccess: number }>;
-  clusterHealth: Array<{
-    label: string;
-    avgR: number;
-    count: number;
-  }>;
-}

package/packages/core/src/mcp/custom-tools.ts

@@ -1,97 +0,0 @@
-// 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';
-import type { SearchEngine } from '../search/index.js';
-
-export interface CustomToolDef {
-  name: string;
-  description: string;
-  query_template: string; // e.g. "{{topic}} best practices"
-  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 function loadCustomTools(toolsDir: string, searchEngine: SearchEngine): LoadedCustomTool[] {
-  if (!existsSync(toolsDir)) return [];
-
-  const tools: LoadedCustomTool[] = [];
-  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: CustomToolDef;
-
-      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: string;
-          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' as const, text: text || 'No results found.' }] };
-        },
-      });
-    } catch {
-      // Skip invalid tool files
-    }
-  }
-
-  return tools;
-}
-
-function parseSimpleYaml(raw: string): CustomToolDef {
-  const result: Record<string, string> = {};
-  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 as unknown as CustomToolDef;
-}