stellavault 0.1.0 → 0.2.1

package/packages/core/src/mcp/server.ts

@@ -1,142 +0,0 @@
-// 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 type { VectorStore } from '../store/types.js';
-import type { SearchEngine } from '../search/index.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';
-import type { DecayEngine } from '../intelligence/decay-engine.js';
-
-export interface McpServerOptions {
-  store: VectorStore;
-  searchEngine: SearchEngine;
-  vaultPath?: string;
-  decayEngine?: DecayEngine;
-}
-
-export function createMcpServer(options: McpServerOptions) {
-  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: unknown;
-      switch (name) {
-        case 'search':
-          result = await handleSearch(searchEngine, args as any);
-          // MCP 검색 이벤트 기록
-          if (decayEngine && result && typeof result === 'object' && 'results' in (result as any)) {
-            const now = new Date().toISOString();
-            for (const r of (result as any).results ?? []) {
-              if (r.documentId) decayEngine.recordAccess({ documentId: r.documentId, type: 'mcp_query', timestamp: now }).catch(() => {});
-            }
-          }
-          break;
-        case 'get-document':
-          result = await handleGetDocument(store, args as any);
-          // MCP 문서 조회 이벤트 기록
-          if (decayEngine && result && typeof result === 'object' && 'id' in (result as any)) {
-            decayEngine.recordAccess({ documentId: (result as any).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 as any);
-          break;
-        case 'generate-claude-md':
-          result = await handleGenerateClaudeMd(searchEngine, store, args as any);
-          break;
-        case 'create-snapshot':
-          result = await handleCreateSnapshot(searchEngine, args as any);
-          break;
-        case 'load-snapshot':
-          result = await handleLoadSnapshot(args as any);
-          break;
-        case 'log-decision':
-          result = await handleLogDecision(vaultPath, args as any);
-          break;
-        case 'find-decisions':
-          result = await handleFindDecisions(vaultPath, args as any);
-          break;
-        case 'export':
-          result = await handleExport(store, args as any);
-          break;
-        case 'get-decay-status':
-          if (!decayEngine) { result = { error: 'Decay engine not available' }; break; }
-          result = await handleGetDecayStatus(decayEngine, args as any);
-          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 as any);
-          return result as any;
-        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: number = 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,
-  };
-}

package/packages/core/src/mcp/tools/agentic-graph.ts

@@ -1,96 +0,0 @@
-// Agentic Graph Construction (P3-F23)
-// AI가 MCP 세션 중 실시간으로 그래프 노드/엣지 생성
-
-import type { VectorStore } from '../../store/types.js';
-import type { Embedder } from '../../indexer/embedder.js';
-import { writeFileSync, mkdirSync } from 'node:fs';
-import { join } from 'node:path';
-
-export function createAgenticGraphTools(store: VectorStore, embedder: Embedder, vaultPath: string) {
-  return [
-    {
-      name: 'create-knowledge-node',
-      description: 'Create a new knowledge note in the vault. AI agents use this to capture decisions, insights, or summaries during a conversation. The note is automatically indexed and appears in the knowledge graph.',
-      inputSchema: {
-        type: 'object' as const,
-        properties: {
-          title: { type: 'string', description: 'Note title' },
-          content: { type: 'string', description: 'Note content (markdown)' },
-          tags: { type: 'array', items: { type: 'string' }, description: 'Tags for categorization' },
-          type: { type: 'string', description: 'Note type: note, decision, insight, summary' },
-          folder: { type: 'string', description: 'Vault subfolder (default: 01_Knowledge)' },
-        },
-        required: ['title', 'content'],
-      },
-      async handler(args: { title: string; content: string; tags?: string[]; type?: string; folder?: string }) {
-        const { title, content, tags = [], type = 'note', folder = '01_Knowledge' } = args;
-
-        // frontmatter 생성
-        const date = new Date().toISOString().slice(0, 10);
-        const fm = [
-          '---',
-          `title: "${title}"`,
-          `type: ${type}`,
-          `source: agent`,
-          `tags: [${tags.map(t => `"${t}"`).join(', ')}]`,
-          `created: ${date}`,
-          `auto_generated: true`,
-          '---',
-        ].join('\n');
-
-        const fullContent = `${fm}\n\n# ${title}\n\n${content}`;
-
-        // vault에 파일 저장
-        const safeTitle = title.replace(/[<>:"/\\|?*]/g, '').replace(/\s+/g, ' ').trim().slice(0, 80);
-        const dir = join(vaultPath, folder);
-        mkdirSync(dir, { recursive: true });
-        const filePath = join(dir, `${safeTitle}.md`);
-        writeFileSync(filePath, fullContent, 'utf-8');
-
-        return {
-          content: [{
-            type: 'text' as const,
-            text: `Created knowledge node: "${title}" at ${folder}/${safeTitle}.md\nTags: ${tags.join(', ') || 'none'}\nType: ${type}\n\nRun 'stellavault index' to add to the graph.`,
-          }],
-        };
-      },
-    },
-    {
-      name: 'create-knowledge-link',
-      description: 'Create a link between two existing notes by adding a wiki-link reference. Strengthens connections in the knowledge graph.',
-      inputSchema: {
-        type: 'object' as const,
-        properties: {
-          sourceTitle: { type: 'string', description: 'Title of the source note' },
-          targetTitle: { type: 'string', description: 'Title of the target note to link to' },
-          context: { type: 'string', description: 'Why these notes are related (added as a comment)' },
-        },
-        required: ['sourceTitle', 'targetTitle'],
-      },
-      async handler(args: { sourceTitle: string; targetTitle: string; context?: string }) {
-        const docs = await store.getAllDocuments();
-        const source = docs.find(d => d.title.toLowerCase().includes(args.sourceTitle.toLowerCase()));
-
-        if (!source) {
-          return { content: [{ type: 'text' as const, text: `Source note "${args.sourceTitle}" not found.` }] };
-        }
-
-        // 소스 노트에 링크 추가
-        const { readFileSync } = await import('node:fs');
-        const fullPath = join(vaultPath, source.filePath);
-        let existing = '';
-        try { existing = readFileSync(fullPath, 'utf-8'); } catch { /* new file */ }
-
-        const linkSection = `\n\n## Related\n\n- [[${args.targetTitle}]]${args.context ? ` — ${args.context}` : ''}\n`;
-        writeFileSync(fullPath, existing + linkSection, 'utf-8');
-
-        return {
-          content: [{
-            type: 'text' as const,
-            text: `Linked "${source.title}" → "${args.targetTitle}"${args.context ? ` (${args.context})` : ''}`,
-          }],
-        };
-      },
-    },
-  ];
-}

package/packages/core/src/mcp/tools/brief.ts

@@ -1,49 +0,0 @@
-// MCP tool: get-morning-brief — Claude 세션 시작 시 자동 브리핑
-
-import type { DecayEngine } from '../../intelligence/decay-engine.js';
-import type { VectorStore } from '../../store/types.js';
-
-export const getMorningBriefToolDef = {
-  name: 'get-morning-brief',
-  description: '오늘의 지식 브리핑을 제공합니다. 감쇠 상태, 리뷰 대상, 최근 활동을 요약합니다. 세션 시작 시 호출하면 유용합니다.',
-  inputSchema: {
-    type: 'object' as const,
-    properties: {},
-  },
-};
-
-export async function handleGetMorningBrief(
-  decayEngine: DecayEngine,
-  store: VectorStore,
-) {
-  const stats = await store.getStats();
-  const report = await decayEngine.computeAll();
-
-  const reviewList = report.topDecaying.slice(0, 5).map(d => ({
-    title: d.title,
-    retrievability: Math.round(d.retrievability * 100) / 100,
-    daysSinceAccess: d.daysSinceAccess,
-  }));
-
-  const unhealthyClusters = report.clusterHealth
-    .filter(c => c.avgR < 0.6)
-    .slice(0, 3)
-    .map(c => ({ label: c.label, avgR: c.avgR, count: c.count }));
-
-  return {
-    greeting: `📚 ${stats.documentCount}개 노트, 전체 건강도 R=${report.averageR}`,
-    summary: {
-      totalDocs: stats.documentCount,
-      averageR: report.averageR,
-      decaying: report.decayingCount,
-      critical: report.criticalCount,
-    },
-    reviewSuggestions: reviewList,
-    unhealthyClusters,
-    tip: report.criticalCount > 0
-      ? `⚠️ ${report.criticalCount}개 노트가 위험 수준입니다. 'stellavault review'로 리뷰하세요.`
-      : report.decayingCount > 0
-        ? `📋 ${report.decayingCount}개 노트가 감쇠 중입니다.`
-        : '✨ 모든 지식이 건강합니다!',
-  };
-}

package/packages/core/src/mcp/tools/decay.ts

@@ -1,40 +0,0 @@
-// Design Ref: §4.2 — MCP tool: get-decay-status
-// Plan SC: SC-04
-
-import type { DecayEngine } from '../../intelligence/decay-engine.js';
-
-export const getDecayStatusToolDef = {
-  name: 'get-decay-status',
-  description: '잊어가는 지식 노트를 조회합니다. 기억 강도(retrievability)가 낮은 노트 목록을 반환하여 리마인드합니다.',
-  inputSchema: {
-    type: 'object' as const,
-    properties: {
-      threshold: { type: 'number', description: '감쇠 임계값 (0~1, default: 0.5). 이 값 이하인 노트를 반환' },
-      limit: { type: 'number', description: '반환할 최대 노트 수 (default: 20)' },
-    },
-  },
-};
-
-export async function handleGetDecayStatus(
-  decayEngine: DecayEngine,
-  args: { threshold?: number; limit?: number },
-) {
-  const threshold = args.threshold ?? 0.5;
-  const limit = args.limit ?? 20;
-
-  const decaying = await decayEngine.getDecaying(threshold, limit);
-
-  return {
-    count: decaying.length,
-    threshold,
-    notes: decaying.map(d => ({
-      title: d.title,
-      retrievability: Math.round(d.retrievability * 100) / 100,
-      stability: Math.round(d.stability * 10) / 10,
-      lastAccess: d.lastAccess,
-    })),
-    tip: decaying.length > 0
-      ? `${decaying.length}개의 노트를 잊어가고 있습니다. 리뷰를 권장합니다.`
-      : '모든 지식이 건강한 상태입니다!',
-  };
-}

package/packages/core/src/mcp/tools/decision-journal.ts

@@ -1,95 +0,0 @@
-// Design Ref: §12.1 F14 — 결정 저널 (기술 결정 자동 기록)
-
-import { writeFileSync, existsSync, mkdirSync, readdirSync, readFileSync } from 'node:fs';
-import { join, resolve } from 'node:path';
-import type { SearchEngine } from '../../search/index.js';
-
-export const logDecisionToolDef = {
-  name: 'log-decision',
-  description: '기술적 결정을 구조화하여 기록합니다. 나중에 "왜 이 선택을 했지?"에 답변할 수 있습니다.',
-  inputSchema: {
-    type: 'object' as const,
-    properties: {
-      title: { type: 'string', description: '결정 제목 (예: Zustand 대신 Jotai 선택)' },
-      context: { type: 'string', description: '결정 배경/상황' },
-      decision: { type: 'string', description: '선택한 내용' },
-      alternatives: { type: 'array', items: { type: 'string' }, description: '고려한 대안들' },
-      reasoning: { type: 'string', description: '선택 이유' },
-      project: { type: 'string', description: '관련 프로젝트명' },
-    },
-    required: ['title', 'decision', 'reasoning'],
-  },
-};
-
-export const findDecisionsToolDef = {
-  name: 'find-decisions',
-  description: '과거 기술 결정을 검색합니다.',
-  inputSchema: {
-    type: 'object' as const,
-    properties: {
-      query: { type: 'string', description: '검색 쿼리' },
-    },
-    required: ['query'],
-  },
-};
-
-export async function handleLogDecision(
-  vaultPath: string,
-  args: {
-    title: string; context?: string; decision: string;
-    alternatives?: string[]; reasoning: string; project?: string;
-  },
-) {
-  const decisionsDir = join(vaultPath, 'decisions');
-  mkdirSync(decisionsDir, { recursive: true });
-
-  const date = new Date().toISOString().slice(0, 10);
-  const slug = args.title.replace(/[^a-zA-Z가-힣0-9\s-]/g, '').replace(/\s+/g, '-').slice(0, 50);
-  if (!slug) throw new Error('Invalid decision title');
-  const fileName = `${date}-${slug}.md`;
-
-  const content = [
-    '---',
-    `title: "${args.title}"`,
-    `date: ${date}`,
-    `project: "${args.project ?? ''}"`,
-    'type: decision',
-    '---',
-    '',
-    `# ${args.title}`,
-    '',
-    args.context ? `## 배경\n\n${args.context}\n` : '',
-    `## 결정\n\n${args.decision}\n`,
-    args.alternatives?.length
-      ? `## 고려한 대안\n\n${args.alternatives.map(a => `- ${a}`).join('\n')}\n`
-      : '',
-    `## 이유\n\n${args.reasoning}\n`,
-  ].filter(Boolean).join('\n');
-
-  const filePath = resolve(decisionsDir, fileName);
-  if (!filePath.startsWith(resolve(decisionsDir))) {
-    throw new Error('Path traversal detected');
-  }
-  writeFileSync(filePath, content, 'utf-8');
-
-  return { saved: filePath, fileName };
-}
-
-export async function handleFindDecisions(vaultPath: string, args: { query: string }) {
-  const decisionsDir = join(vaultPath, 'decisions');
-  if (!existsSync(decisionsDir)) return { decisions: [], message: 'No decisions directory' };
-
-  const files = readdirSync(decisionsDir).filter(f => f.endsWith('.md'));
-  const query = args.query.toLowerCase();
-
-  const matches = files
-    .map(f => {
-      const content = readFileSync(join(decisionsDir, f), 'utf-8');
-      const score = content.toLowerCase().includes(query) ? 1 : 0;
-      return { file: f, content: content.slice(0, 300), score };
-    })
-    .filter(m => m.score > 0)
-    .slice(0, 10);
-
-  return { decisions: matches, total: files.length };
-}

package/packages/core/src/mcp/tools/export.ts

@@ -1,72 +0,0 @@
-// Design Ref: §12.1 F20 — 지식 내보내기 포맷 (락인 방지)
-
-import { writeFileSync, mkdirSync } from 'node:fs';
-import { join, dirname, resolve } from 'node:path';
-import { homedir } from 'node:os';
-import type { VectorStore } from '../../store/types.js';
-
-const ALLOWED_EXPORT_DIRS = [
-  resolve(homedir(), '.stellavault'),
-  resolve('.'),
-];
-
-function validateExportPath(outputPath: string): string {
-  const resolved = resolve(outputPath);
-  const isAllowed = ALLOWED_EXPORT_DIRS.some(dir => resolved.startsWith(resolve(dir)));
-  if (!isAllowed) {
-    throw new Error(`Export path must be within current directory or ~/.stellavault/. Got: ${resolved}`);
-  }
-  return resolved;
-}
-
-export const exportToolDef = {
-  name: 'export',
-  description: '벡터 DB의 문서와 메타데이터를 JSON 파일로 내보냅니다. 다른 도구로 이전 가능.',
-  inputSchema: {
-    type: 'object' as const,
-    properties: {
-      outputPath: { type: 'string', description: '출력 파일 경로 (예: ./export.json)' },
-      format: { type: 'string', enum: ['json', 'csv'], description: '출력 포맷 (기본: json)' },
-    },
-    required: ['outputPath'],
-  },
-};
-
-export async function handleExport(
-  store: VectorStore,
-  args: { outputPath: string; format?: string },
-) {
-  const docs = await store.getAllDocuments();
-  const stats = await store.getStats();
-  const topics = await store.getTopics();
-
-  const safePath = validateExportPath(args.outputPath);
-  mkdirSync(dirname(safePath), { recursive: true });
-
-  if (args.format === 'csv') {
-    const header = 'id,filePath,title,tags,lastModified,contentHash';
-    const rows = docs.map(d =>
-      `"${d.id}","${d.filePath}","${d.title.replace(/"/g, '""')}","${d.tags.join(';')}","${d.lastModified}","${d.contentHash}"`
-    );
-    writeFileSync(safePath, [header, ...rows].join('\n'), 'utf-8');
-  } else {
-    const exported = {
-      exportedAt: new Date().toISOString(),
-      version: '1.0',
-      stats,
-      topics,
-      documents: docs.map(d => ({
-        id: d.id,
-        filePath: d.filePath,
-        title: d.title,
-        tags: d.tags,
-        frontmatter: d.frontmatter,
-        lastModified: d.lastModified,
-        contentLength: d.content.length,
-      })),
-    };
-    writeFileSync(safePath, JSON.stringify(exported, null, 2), 'utf-8');
-  }
-
-  return { exported: docs.length, path: safePath, format: args.format ?? 'json' };
-}

package/packages/core/src/mcp/tools/federated-search.ts

@@ -1,43 +0,0 @@
-// MCP Tool: federated-search (Federation Phase 1b)
-// AI 에이전트가 연합 네트워크를 검색
-
-import type { FederatedSearch } from '../../federation/search.js';
-
-export function createFederatedSearchTool(federatedSearch: FederatedSearch | null) {
-  return {
-    name: 'federated-search',
-    description: 'Search across all connected Federation peers. Returns results from other Stellavault nodes in the P2P network. Only titles, similarity scores, and 50-char snippets are shared — no raw text leaves any node.',
-    inputSchema: {
-      type: 'object' as const,
-      properties: {
-        query: { type: 'string', description: 'Search query' },
-        limit: { type: 'number', description: 'Max results per peer (default: 5)' },
-      },
-      required: ['query'],
-    },
-    async handler(args: { query: string; limit?: number }) {
-      if (!federatedSearch) {
-        return { content: [{ type: 'text' as const, text: 'Federation not active. Run `sv federate join` first.' }] };
-      }
-
-      const results = await federatedSearch.search(args.query, { limit: args.limit ?? 5 });
-
-      if (results.length === 0) {
-        return { content: [{ type: 'text' as const, text: 'No results from federation peers. Either no peers connected or no matching documents.' }] };
-      }
-
-      const lines = [
-        `🌐 Federation Search: "${args.query}" — ${results.length} results from ${new Set(results.map(r => r.peerId)).size} peers`,
-        '',
-      ];
-
-      for (const r of results) {
-        lines.push(`**${r.title}** (${Math.round(r.similarity * 100)}%) [${r.peerName}]`);
-        lines.push(`  ${r.snippet}...`);
-        lines.push('');
-      }
-
-      return { content: [{ type: 'text' as const, text: lines.join('\n') }] };
-    },
-  };
-}

package/packages/core/src/mcp/tools/generate-claude-md.ts

@@ -1,130 +0,0 @@
-// Design Ref: §12.1 F13 — CLAUDE.md 자동 생성기 (킬러 유스케이스)
-
-import type { SearchEngine } from '../../search/index.js';
-import type { VectorStore } from '../../store/types.js';
-
-export const generateClaudeMdToolDef = {
-  name: 'generate-claude-md',
-  description: '프로젝트명을 기반으로 관련 지식(아키텍처, 패턴, 교훈, 결정사항)을 검색하여 CLAUDE.md 초안을 자동 생성합니다.',
-  inputSchema: {
-    type: 'object' as const,
-    properties: {
-      projectName: { type: 'string', description: '프로젝트명 또는 주요 키워드' },
-      topics: {
-        type: 'array',
-        items: { type: 'string' },
-        description: '추가 검색할 토픽 (예: ["인증", "배포", "성능"])',
-      },
-    },
-    required: ['projectName'],
-  },
-};
-
-export async function handleGenerateClaudeMd(
-  searchEngine: SearchEngine,
-  store: VectorStore,
-  args: { projectName: string; topics?: string[] },
-) {
-  const { projectName, topics = [] } = args;
-
-  // 프로젝트 관련 지식 검색 (여러 관점)
-  const queries = [
-    `${projectName} 아키텍처 설계`,
-    `${projectName} 패턴 컨벤션`,
-    `${projectName} 교훈 실수 주의사항`,
-    `${projectName} 기술 스택 의존성`,
-    ...topics.map(t => `${projectName} ${t}`),
-  ];
-
-  const allResults = new Map<string, { title: string; content: string; score: number; category: string }>();
-
-  for (const query of queries) {
-    const results = await searchEngine.search({ query, limit: 3 });
-    const category = query.replace(projectName, '').trim();
-    for (const r of results) {
-      const key = r.chunk.id;
-      if (!allResults.has(key) || (allResults.get(key)!.score < r.score)) {
-        allResults.set(key, {
-          title: `${r.document.title} §${r.chunk.heading}`,
-          content: r.chunk.content.slice(0, 500),
-          score: r.score,
-          category,
-        });
-      }
-    }
-  }
-
-  // 카테고리별 분류
-  const sorted = [...allResults.values()].sort((a, b) => b.score - a.score);
-
-  // CLAUDE.md 초안 생성
-  const sections: string[] = [];
-  sections.push(`# ${projectName} — CLAUDE.md`);
-  sections.push('');
-  sections.push('> 이 파일은 evan-knowledge-hub MCP에서 자동 생성되었습니다.');
-  sections.push(`> 생성일: ${new Date().toISOString().slice(0, 10)}`);
-  sections.push(`> 참조 지식: ${sorted.length}건`);
-  sections.push('');
-
-  // 아키텍처 섹션
-  const archResults = sorted.filter(r => r.category.includes('아키텍처') || r.category.includes('설계'));
-  if (archResults.length > 0) {
-    sections.push('## 아키텍처 & 설계');
-    sections.push('');
-    for (const r of archResults.slice(0, 3)) {
-      sections.push(`### ${r.title}`);
-      sections.push(r.content.trim());
-      sections.push('');
-    }
-  }
-
-  // 패턴/컨벤션 섹션
-  const patternResults = sorted.filter(r => r.category.includes('패턴') || r.category.includes('컨벤션'));
-  if (patternResults.length > 0) {
-    sections.push('## 코딩 패턴 & 컨벤션');
-    sections.push('');
-    for (const r of patternResults.slice(0, 3)) {
-      sections.push(`### ${r.title}`);
-      sections.push(r.content.trim());
-      sections.push('');
-    }
-  }
-
-  // 교훈 섹션
-  const lessonResults = sorted.filter(r => r.category.includes('교훈') || r.category.includes('실수'));
-  if (lessonResults.length > 0) {
-    sections.push('## 교훈 & 주의사항');
-    sections.push('');
-    for (const r of lessonResults.slice(0, 5)) {
-      sections.push(`- **${r.title}**: ${r.content.slice(0, 200).replace(/\n/g, ' ').trim()}`);
-    }
-    sections.push('');
-  }
-
-  // 기타 관련 지식
-  const otherResults = sorted.filter(r =>
-    !r.category.includes('아키텍처') && !r.category.includes('설계') &&
-    !r.category.includes('패턴') && !r.category.includes('교훈') && !r.category.includes('실수')
-  );
-  if (otherResults.length > 0) {
-    sections.push('## 관련 지식');
-    sections.push('');
-    for (const r of otherResults.slice(0, 5)) {
-      sections.push(`- **${r.title}** (score: ${r.score.toFixed(3)})`);
-    }
-    sections.push('');
-  }
-
-  const claudeMd = sections.join('\n');
-
-  return {
-    content: claudeMd,
-    stats: {
-      queriesRun: queries.length,
-      uniqueResults: sorted.length,
-      sections: ['아키텍처', '패턴', '교훈', '관련 지식'].filter((_, i) =>
-        [archResults, patternResults, lessonResults, otherResults][i].length > 0
-      ),
-    },
-  };
-}