@thinkdata/cli 0.2.3 → 0.3.0

package/dist/mcp/tools.js

@@ -0,0 +1,652 @@
+/**
+ * MCP Tools 등록
+ *
+ * Tools는 부작용(Side-effect)이 있는 액션을 노출합니다.
+ * AI 에이전트가 ThinkERD 데이터를 조회하거나 스키마 변경을 제안할 수 있습니다.
+ *
+ * @module tools
+ */
+import { z } from 'zod';
+export function registerTools(server, client) {
+    // ── get_entity: 엔터티 상세 조회 ──
+    server.tool('get_entity', 'ThinkERD 다이어그램에서 특정 엔터티의 컬럼, 타입, PK/FK 정보를 조회합니다.', {
+        diagramId: z.string().describe('다이어그램 ID'),
+        entityId: z.string().describe('엔터티 ID'),
+    }, async ({ diagramId, entityId }) => {
+        try {
+            const entity = await client.getEntity(diagramId, entityId);
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify(entity, null, 2),
+                    }],
+            };
+        }
+        catch (err) {
+            return {
+                content: [{
+                        type: 'text',
+                        text: `Error: ${err instanceof Error ? err.message : String(err)}`,
+                    }],
+                isError: true,
+            };
+        }
+    });
+    // ── search_entities: 엔터티 검색 ──
+    server.tool('search_entities', 'ThinkERD 다이어그램에서 이름으로 엔터티를 검색합니다. 논리명/물리명 모두 검색 가능합니다.', {
+        diagramId: z.string().describe('다이어그램 ID'),
+        query: z.string().describe('검색 키워드 (엔터티 논리명 또는 물리명)'),
+    }, async ({ diagramId, query }) => {
+        try {
+            const entities = await client.searchEntities(diagramId, query);
+            const summary = entities.map(e => ({
+                id: e.id,
+                name: e.name,
+                tableName: e.tableName,
+                role: e.entityRole,
+                columnCount: e.columns.length,
+                columns: e.columns.map(c => `${c.name} (${c.type})${c.isPrimaryKey ? ' [PK]' : ''}${c.isForeignKey ? ' [FK]' : ''}`),
+            }));
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify(summary, null, 2),
+                    }],
+            };
+        }
+        catch (err) {
+            return {
+                content: [{
+                        type: 'text',
+                        text: `Error: ${err instanceof Error ? err.message : String(err)}`,
+                    }],
+                isError: true,
+            };
+        }
+    });
+    // ── generate_ddl: DDL 생성 ──
+    server.tool('generate_ddl', 'ThinkERD 다이어그램의 DDL(CREATE TABLE 구문)을 생성합니다. PostgreSQL, MySQL, Oracle 등 다양한 방언을 지원합니다.', {
+        diagramId: z.string().describe('다이어그램 ID'),
+        dialect: z.enum(['postgresql', 'mysql', 'oracle', 'mssql', 'sqlite'])
+            .optional()
+            .default('postgresql')
+            .describe('SQL 방언 (기본값: postgresql)'),
+    }, async ({ diagramId, dialect }) => {
+        try {
+            const ddl = await client.generateDDL(diagramId, dialect);
+            return {
+                content: [{
+                        type: 'text',
+                        text: typeof ddl === 'string' ? ddl : JSON.stringify(ddl),
+                    }],
+            };
+        }
+        catch (err) {
+            return {
+                content: [{
+                        type: 'text',
+                        text: `Error: ${err instanceof Error ? err.message : String(err)}`,
+                    }],
+                isError: true,
+            };
+        }
+    });
+    // ── validate_schema: 스키마 검증 ──
+    server.tool('validate_schema', 'ThinkERD 다이어그램의 스키마를 검증합니다. 누락된 PK, 미연결 FK, 비표준 네이밍 등을 점검합니다.', {
+        diagramId: z.string().describe('다이어그램 ID'),
+    }, async ({ diagramId }) => {
+        try {
+            const data = await client.getDiagram(diagramId);
+            const issues = [];
+            // PK 누락 검사
+            for (const entity of data.entities) {
+                const hasPK = entity.columns.some(c => c.isPrimaryKey);
+                if (!hasPK) {
+                    issues.push(`⚠️ [${entity.name}] PK(Primary Key)가 없습니다.`);
+                }
+            }
+            // 컬럼 없는 엔터티 검사
+            for (const entity of data.entities) {
+                if (entity.columns.length === 0) {
+                    issues.push(`⚠️ [${entity.name}] 컬럼이 하나도 없습니다.`);
+                }
+            }
+            // 고립 엔터티 검사 (관계가 하나도 없는)
+            const connectedIds = new Set();
+            for (const rel of data.relationships) {
+                connectedIds.add(rel.sourceEntityId);
+                connectedIds.add(rel.targetEntityId);
+            }
+            for (const entity of data.entities) {
+                if (!connectedIds.has(entity.id) && data.entities.length > 1) {
+                    issues.push(`ℹ️ [${entity.name}] 다른 엔터티와 관계가 없는 고립 엔터티입니다.`);
+                }
+            }
+            const summary = issues.length === 0
+                ? `✅ 스키마 검증 완료: ${data.entities.length}개 엔터티, 문제 없음.`
+                : `🔍 스키마 검증 완료: ${data.entities.length}개 엔터티, ${issues.length}개 이슈 발견.\n\n${issues.join('\n')}`;
+            return {
+                content: [{
+                        type: 'text',
+                        text: summary,
+                    }],
+            };
+        }
+        catch (err) {
+            return {
+                content: [{
+                        type: 'text',
+                        text: `Error: ${err instanceof Error ? err.message : String(err)}`,
+                    }],
+                isError: true,
+            };
+        }
+    });
+    // ── harvest_schema_semantics: 역공학 컨텍스트 추출 ──
+    server.tool('harvest_schema_semantics', 'ThinkERD 다이어그램의 물리 테이블 목록을 기반으로 역공학 추론을 실행하여 논리명, 설명, 관계 등의 시멘틱 메타데이터를 반환합니다.', {
+        diagramId: z.string().describe('다이어그램 ID'),
+        tableNames: z.array(z.string()).optional().describe('추출할 물리 테이블명 목록. 생략 시 전체 다이어그램 대상'),
+    }, async ({ diagramId, tableNames }) => {
+        try {
+            const data = await client.getDiagram(diagramId);
+            let entities = data.entities;
+            if (tableNames && tableNames.length > 0) {
+                const tableSet = new Set(tableNames.map(t => t.toUpperCase()));
+                entities = entities.filter(e => e.tableName && tableSet.has(e.tableName.toUpperCase()));
+            }
+            const { extractFrequentTokens } = await import('@thinkdata/semantic-core');
+            const harvested = extractFrequentTokens(entities, [], 1);
+            const summary = {
+                extractedSemantics: harvested,
+                relationships: data.relationships.filter(r => entities.some(e => e.id === r.sourceEntityId) ||
+                    entities.some(e => e.id === r.targetEntityId))
+            };
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify(summary, null, 2),
+                    }],
+            };
+        }
+        catch (err) {
+            return {
+                content: [{
+                        type: 'text',
+                        text: `Error: ${err instanceof Error ? err.message : String(err)}`,
+                    }],
+                isError: true,
+            };
+        }
+    });
+    // ── propose_schema_change: 스키마 변경 제안 ──
+    server.tool('propose_schema_change', '외부 AI가 ThinkERD 다이어그램에 스키마 변경을 제안합니다. 사용자 승인이 필요한 Draft로 전송됩니다.', {
+        diagramId: z.string().describe('대상 다이어그램 ID'),
+        entityName: z.string().describe('변경 대상 엔터티명 (논리명 또는 물리명)'),
+        changeType: z.enum(['add_column', 'modify_column', 'add_entity'])
+            .describe('변경 유형'),
+        changeData: z.record(z.unknown())
+            .describe('변경 데이터 (JSON). add_column: {name, type, logicalName}, add_entity: {name, tableName, columns}'),
+        reason: z.string().describe('변경 사유'),
+    }, async ({ diagramId, entityName, changeType, changeData, reason }) => {
+        try {
+            const draft = await client.proposeSchemaChange(diagramId, {
+                entityName,
+                changeType,
+                changeData,
+                reason,
+            });
+            return {
+                content: [{
+                        type: 'text',
+                        text: `✅ 스키마 변경 제안이 ThinkERD에 전송되었습니다.\n\n` +
+                            `Draft ID: ${draft.draft_id}\n` +
+                            `상태: ${draft.status}\n` +
+                            `대상: ${entityName}\n` +
+                            `유형: ${changeType}\n` +
+                            `사유: ${reason}\n\n` +
+                            `⚠️ ThinkERD에서 사용자가 이 제안을 승인해야 적용됩니다.`,
+                    }],
+            };
+        }
+        catch (err) {
+            return {
+                content: [{
+                        type: 'text',
+                        text: `Error: ${err instanceof Error ? err.message : String(err)}`,
+                    }],
+                isError: true,
+            };
+        }
+    });
+    // ── get_business_dictionary: 표준 단어/용어 사전 조회 ──
+    server.tool('get_business_dictionary', '사내 표준 단어/용어 사전에서 키워드를 검색하여 논리명-물리명 매핑 가이드를 제공합니다. '
+        + '각 단어의 동의어(synonyms)도 함께 반환하므로, 사용자가 쓴 말이 사내에서 어떤 표준 단어인지 되짚을 수 있습니다.', {
+        projectId: z.string().describe('프로젝트 ID'),
+        keyword: z.string().optional().describe('검색어 (생략 시 전체 조회). 동의어로도 검색됩니다'),
+    }, async ({ projectId, keyword }) => {
+        try {
+            let dictionary = await client.getDictionary(projectId);
+            if (keyword) {
+                const lowerKeyword = keyword.toLowerCase();
+                // 동의어까지 훑는다 — 이 도구의 값은 "사용자가 쓴 말"에서 표준 단어로
+                // 되짚는 데 있고, 그 말은 정의상 논리명이 아니라 동의어 쪽에 있다
+                dictionary = dictionary.filter(w => w.logicalName.toLowerCase().includes(lowerKeyword) ||
+                    w.physicalName.toLowerCase().includes(lowerKeyword) ||
+                    (w.synonyms ?? []).some(s => s.toLowerCase().includes(lowerKeyword)) ||
+                    (w.classifier && w.classifier.toLowerCase().includes(lowerKeyword)));
+            }
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify(dictionary, null, 2),
+                    }],
+            };
+        }
+        catch (err) {
+            return {
+                content: [{
+                        type: 'text',
+                        text: `Error: ${err instanceof Error ? err.message : String(err)}`,
+                    }],
+                isError: true,
+            };
+        }
+    });
+    // [2026-08-30 삭제] `push_ddl_and_harvest`와 `update_erd_from_code`가 여기 있었다.
+    // 서버 쪽 엔드포인트가 아무 일도 하지 않으면서 `status: "success"`를 돌려주고
+    // 메시지 끝에만 "(Mock)"을 붙였다 — 사람은 메시지를 읽지만 **에이전트는 status를
+    // 읽는다.** 도구 목록은 LLM이 읽는 메뉴판이고, 메뉴에 있는데 안 나오는 음식은
+    // 없는 음식보다 나쁘다.
+    //
+    // 스키마 변경은 `propose_schema_change` → ThinkERD에서 승인하는 경로로만 간다.
+    // ── analyze_legacy_sql: 레거시 SQL 분석 ──
+    server.tool('analyze_legacy_sql', '복잡한 레거시 SQL 쿼리를 분석하여 ERD 다이어그램에 기반한 테이블들의 비즈니스 의미 및 연관 관계를 반환합니다.', {
+        diagramId: z.string().describe('다이어그램 ID'),
+        sqlQuery: z.string().describe('분석할 대상 SQL 쿼리'),
+    }, async ({ diagramId, sqlQuery }) => {
+        try {
+            const data = await client.getDiagram(diagramId);
+            const queryUpper = sqlQuery.toUpperCase();
+            // SQL에 포함된 테이블명 추출 (단순 포함 여부 확인)
+            const matchedEntities = data.entities.filter(e => e.tableName && queryUpper.includes(e.tableName.toUpperCase()));
+            const matchedEntityIds = new Set(matchedEntities.map(e => e.id));
+            const matchedRelationships = data.relationships.filter(r => matchedEntityIds.has(r.sourceEntityId) || matchedEntityIds.has(r.targetEntityId));
+            const { extractFrequentTokens } = await import('@thinkdata/semantic-core');
+            const harvested = extractFrequentTokens(matchedEntities, [], 1);
+            const result = {
+                message: "SQL 내에서 식별된 테이블에 대한 비즈니스 분석 결과입니다.",
+                matchedTables: matchedEntities.map(e => ({
+                    tableName: e.tableName,
+                    logicalName: e.logicalName,
+                    description: e.columns.map((c) => `${c.name}(${c.type}) ${c.logicalName || ''}`).join(', ')
+                })),
+                semanticHarvest: harvested,
+                relevantRelationships: matchedRelationships
+            };
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify(result, null, 2),
+                    }],
+            };
+        }
+        catch (err) {
+            return {
+                content: [{
+                        type: 'text',
+                        text: `Error: ${err instanceof Error ? err.message : String(err)}`,
+                    }],
+                isError: true,
+            };
+        }
+    });
+    // ── semantic_search: 비즈니스 용어 기반 시멘틱 검색 ──
+    server.tool('semantic_search', '비즈니스 용어(자연어)로 다이어그램의 엔터티·컬럼을 검색합니다. 동의어, 설명, 논리명을 모두 활용하여 매칭하며, 매칭 유형(논리명/동의어/설명/부분매칭/컬럼)을 함께 반환합니다.', {
+        diagramId: z.string().describe('다이어그램 ID'),
+        query: z.string().describe('검색 키워드 (비즈니스 용어, 논리명, 동의어 등)'),
+        maxResults: z.number().optional().describe('최대 결과 수 (기본 10)'),
+    }, async ({ diagramId, query, maxResults }) => {
+        try {
+            const data = await client.getDiagram(diagramId);
+            const entities = data.entities || [];
+            const limit = maxResults || 10;
+            const q = query.toLowerCase();
+            const results = [];
+            for (const entity of entities) {
+                const e = entity;
+                // 논리명 매칭
+                if (e.name?.toLowerCase().includes(q) || e.logicalName?.toLowerCase().includes(q)) {
+                    results.push({
+                        entityId: e.id,
+                        entityName: e.name,
+                        tableName: e.tableName,
+                        matchType: 'logicalName',
+                        matchedOn: e.name || e.logicalName,
+                        description: e.description || null,
+                    });
+                    continue;
+                }
+                // 동의어 매칭
+                if (Array.isArray(e.synonyms)) {
+                    const syn = e.synonyms.find((s) => s.toLowerCase().includes(q));
+                    if (syn) {
+                        results.push({
+                            entityId: e.id,
+                            entityName: e.name,
+                            tableName: e.tableName,
+                            matchType: 'synonym',
+                            matchedOn: syn,
+                            description: e.description || null,
+                        });
+                        continue;
+                    }
+                }
+                // 설명 매칭
+                if (e.description?.toLowerCase().includes(q)) {
+                    results.push({
+                        entityId: e.id,
+                        entityName: e.name,
+                        tableName: e.tableName,
+                        matchType: 'description',
+                        matchedOn: e.description,
+                    });
+                    continue;
+                }
+                // 컬럼 매칭
+                for (const col of entity.columns) {
+                    const c = col;
+                    if (c.logicalName?.toLowerCase().includes(q) || c.name?.toLowerCase().includes(q) || c.description?.toLowerCase().includes(q)) {
+                        results.push({
+                            entityId: e.id,
+                            entityName: e.name,
+                            tableName: e.tableName,
+                            matchType: 'column',
+                            matchedColumn: c.name,
+                            matchedColumnLogical: c.logicalName,
+                        });
+                        break; // 한 엔터티에서 하나만
+                    }
+                }
+            }
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({
+                            query,
+                            totalResults: results.length,
+                            results: results.slice(0, limit),
+                        }, null, 2),
+                    }],
+            };
+        }
+        catch (err) {
+            return {
+                content: [{
+                        type: 'text',
+                        text: `Error: ${err instanceof Error ? err.message : String(err)}`,
+                    }],
+                isError: true,
+            };
+        }
+    });
+    // ── get_business_context: 엔터티의 비즈니스 컨텍스트 조회 ──
+    server.tool('get_business_context', '특정 엔터티의 비즈니스 의미, 동의어, 코드값, 관계를 포함한 전체 비즈니스 컨텍스트를 조회합니다. Text-to-SQL이나 문서 생성의 참고자료로 활용됩니다.', {
+        diagramId: z.string().describe('다이어그램 ID'),
+        entityId: z.string().describe('엔터티 ID'),
+    }, async ({ diagramId, entityId }) => {
+        try {
+            const entity = await client.getEntity(diagramId, entityId);
+            const data = await client.getDiagram(diagramId);
+            const e = entity;
+            // 관련 관계 조회
+            const relationships = (data.relationships || []).filter(r => r.sourceEntityId === entityId || r.targetEntityId === entityId);
+            const businessContext = {
+                entity: {
+                    id: e.id,
+                    name: e.name,
+                    tableName: e.tableName,
+                    logicalName: e.logicalName || e.name,
+                    description: e.description || null,
+                    synonyms: e.synonyms || [],
+                    entityRole: e.entityRole || null,
+                },
+                columns: entity.columns.map((c) => ({
+                    name: c.name,
+                    logicalName: c.logicalName || null,
+                    type: c.type,
+                    isPrimaryKey: c.isPrimaryKey || false,
+                    isForeignKey: c.isForeignKey || false,
+                    description: c.description || null,
+                    domainValues: c.domainValues || null,
+                })),
+                relationships: relationships.map(r => ({
+                    relatedEntity: r.sourceEntityId === entityId ? r.targetEntityName : r.sourceEntityName,
+                    direction: r.sourceEntityId === entityId ? 'outgoing' : 'incoming',
+                    type: r.type,
+                    cardinality: `${r.sourceCardinality}:${r.targetCardinality}`,
+                })),
+            };
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify(businessContext, null, 2),
+                    }],
+            };
+        }
+        catch (err) {
+            return {
+                content: [{
+                        type: 'text',
+                        text: `Error: ${err instanceof Error ? err.message : String(err)}`,
+                    }],
+                isError: true,
+            };
+        }
+    });
+    // ── generate_sql: 자연어 → SQL 생성 ──
+    server.tool('generate_sql', '**한 다이어그램의 물리 스키마만** 보고 SQL 작성용 컨텍스트를 반환합니다. '
+        + '⚠️ 이 도구는 프로젝트 전역 의미 계층(비즈니스 모델 발행본·표준 사전 동의어·온톨로지)을 **보지 않습니다.** '
+        + '업무 용어("고객", "배송중인 주문")가 섞인 질문이라면 **`get_project_context`를 먼저 호출하십시오.** '
+        + '이 도구는 대상 다이어그램이 이미 특정되어 있고 물리 컬럼 구조만 필요할 때 쓰십시오.', {
+        diagramId: z.string().describe('다이어그램 ID'),
+        question: z.string().describe('자연어 질문 (예: "부서별 평균 급여가 5천만원 이상인 부서")'),
+        dialect: z.string().optional().describe('SQL 방언 (postgresql, mysql, oracle, mssql). 기본: postgresql'),
+    }, async ({ diagramId, question, dialect }) => {
+        try {
+            const data = await client.getDiagram(diagramId);
+            const entities = data.entities || [];
+            const relationships = data.relationships || [];
+            // 시멘틱 컨텍스트 구성
+            const schemaContext = entities.map(e => {
+                const ea = e;
+                return {
+                    tableName: e.tableName,
+                    logicalName: e.name || ea.logicalName,
+                    description: ea.description || null,
+                    synonyms: ea.synonyms || [],
+                    columns: e.columns.map((c) => ({
+                        name: c.name,
+                        logicalName: c.logicalName || null,
+                        type: c.type,
+                        isPrimaryKey: c.isPrimaryKey || false,
+                        isForeignKey: c.isForeignKey || false,
+                        domainValues: c.domainValues || null,
+                    })),
+                };
+            });
+            const relationshipContext = relationships.map(r => ({
+                from: `${r.sourceEntityName} (${r.sourceEntityId})`,
+                to: `${r.targetEntityName} (${r.targetEntityId})`,
+                type: r.type,
+            }));
+            // LLM 호출 대신 컨텍스트를 반환하여 외부 AI가 SQL 생성에 활용하도록 함
+            const result = {
+                question,
+                dialect: dialect || 'postgresql',
+                schemaContext,
+                relationshipContext,
+                hint: `위 스키마 컨텍스트를 기반으로 "${question}"에 대한 ${dialect || 'postgresql'} SQL을 생성하세요. tableName을 테이블 참조에, columns[].name을 컬럼 참조에 사용하세요. 동의어(synonyms)와 코드값(domainValues)을 활용하여 정확한 매핑을 수행하세요.`,
+            };
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify(result, null, 2),
+                    }],
+            };
+        }
+        catch (err) {
+            return {
+                content: [{
+                        type: 'text',
+                        text: `Error: ${err instanceof Error ? err.message : String(err)}`,
+                    }],
+                isError: true,
+            };
+        }
+    });
+    // ══════════════════════════════════════════════════════════════════
+    // ── 프로젝트 전체 온톨로지 Tools (Context Provider 연동) ──
+    // ══════════════════════════════════════════════════════════════════
+    // ── get_project_context: 프로젝트 시멘틱 컨텍스트 검색 ──
+    server.tool('get_project_context', '**업무 용어가 섞인 질문에는 이 도구를 먼저 쓰십시오.** 자연어 질문으로 프로젝트 전체에서 관련 엔터티를 '
+        + '시멘틱 검색(Graph RAG)합니다. 이 조직이 쓰는 **동의어·코드값의 뜻·비즈니스 모델 발행본**까지 보므로, '
+        + '"고객"처럼 물리 스키마에 없는 말도 실제 테이블로 연결합니다. '
+        + '응답의 `usedFallback: true`는 **질문의 개념을 찾지 못했다**는 뜻입니다 — 그 컨텍스트로 SQL을 만들지 말고 '
+        + '모른다고 답하거나 사용자에게 용어를 되물으십시오.', {
+        projectId: z.string().describe('프로젝트 ID'),
+        question: z.string().describe('자연어 질문 (예: "부서별 급여 총액", "VIP 고객의 최근 주문")'),
+    }, async ({ projectId, question }) => {
+        try {
+            const result = await client.getProjectContext(projectId, question);
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify(result, null, 2),
+                    }],
+            };
+        }
+        catch (err) {
+            return {
+                content: [{
+                        type: 'text',
+                        text: `Error: ${err instanceof Error ? err.message : String(err)}`,
+                    }],
+                isError: true,
+            };
+        }
+    });
+    // ── find_join_path: JOIN 경로 탐색 ──
+    server.tool('find_join_path', '두 엔터티(테이블) 간 최적 JOIN 경로를 탐색합니다. BFS 기반으로 최단 경로를 찾으며, 중간 테이블과 관계명을 포함합니다. ' +
+        '각 구간에 물리 테이블명·FK 컬럼쌍(on)·진행 방향 카디널리티가 실려 있으므로, **조인 조건을 추측하지 말고 on 값을 그대로 ON 절에 쓰십시오.** ' +
+        'joinable=false면 FK 매핑이나 물리 테이블명이 없어 SQL을 조립할 수 없다는 뜻이며, 사유는 warnings에 있습니다.', {
+        projectId: z.string().describe('프로젝트 ID'),
+        from: z.string().describe('출발 엔터티 이름 (논리명 또는 물리명)'),
+        to: z.string().describe('도착 엔터티 이름 (논리명 또는 물리명)'),
+    }, async ({ projectId, from, to }) => {
+        try {
+            const result = await client.findJoinPath(projectId, from, to);
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify(result, null, 2),
+                    }],
+            };
+        }
+        catch (err) {
+            return {
+                content: [{
+                        type: 'text',
+                        text: `Error: ${err instanceof Error ? err.message : String(err)}`,
+                    }],
+                isError: true,
+            };
+        }
+    });
+    // ── get_project_summary: 프로젝트 스키마 요약 ──
+    server.tool('get_project_summary', '프로젝트 전체의 데이터 모델 요약을 반환합니다. 엔터티 수, 관계 수, 주제영역(Subject Area) 구성, RDF 트리플 수 등을 포함합니다. 프로젝트 온보딩이나 전체 구조 파악에 유용합니다.', {
+        projectId: z.string().describe('프로젝트 ID'),
+    }, async ({ projectId }) => {
+        try {
+            const result = await client.getProjectSummary(projectId);
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify(result, null, 2),
+                    }],
+            };
+        }
+        catch (err) {
+            return {
+                content: [{
+                        type: 'text',
+                        text: `Error: ${err instanceof Error ? err.message : String(err)}`,
+                    }],
+                isError: true,
+            };
+        }
+    });
+    // ── query_ontology: SPARQL 직접 실행 ──
+    server.tool('query_ontology', '프로젝트의 온톨로지 그래프에 SPARQL 쿼리를 직접 실행합니다. 고급 사용자가 정교한 시멘틱 질의를 수행할 때 사용합니다.', {
+        projectId: z.string().describe('프로젝트 ID'),
+        query: z.string().describe('SPARQL SELECT 쿼리문'),
+    }, async ({ projectId, query }) => {
+        try {
+            const result = await client.queryOntology(projectId, query);
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify(result, null, 2),
+                    }],
+            };
+        }
+        catch (err) {
+            return {
+                content: [{
+                        type: 'text',
+                        text: `Error: ${err instanceof Error ? err.message : String(err)}`,
+                    }],
+                isError: true,
+            };
+        }
+    });
+    // ── check_metadata_quality: 메타데이터 품질 점검 ──
+    server.tool('check_metadata_quality', '프로젝트의 메타데이터 풍부도를 분석합니다. 설명, 동의어, 속성 입력률을 기반으로 전체 품질 점수를 산출하고, 개선이 필요한 엔터티 목록을 제안합니다.', {
+        projectId: z.string().describe('프로젝트 ID'),
+    }, async ({ projectId }) => {
+        try {
+            const result = await client.checkMetadataQuality(projectId);
+            // 사람이 읽기 쉬운 요약 포맷
+            const summary = [
+                `📊 메타데이터 품질 보고서`,
+                `평균 풍부도: ${result.avgRichness}%`,
+                `총 엔터티: ${result.entityCount}개`,
+                ``,
+                `🟢 완전 (≥70%): ${result.breakdown?.complete || 0}개`,
+                `🟡 부분 (40-69%): ${result.breakdown?.partial || 0}개`,
+                `🔴 미입력 (<40%): ${result.breakdown?.missing || 0}개`,
+            ];
+            if (result.suggestions && result.suggestions.length > 0) {
+                summary.push('', '💡 개선 제안 (풍부도 낮은 순):');
+                for (const s of result.suggestions.slice(0, 10)) {
+                    summary.push(`  • ${s.entity} (${s.richness}%) — 누락: ${s.missing.join(', ')}`);
+                }
+            }
+            return {
+                content: [{
+                        type: 'text',
+                        text: summary.join('\n'),
+                    }],
+            };
+        }
+        catch (err) {
+            return {
+                content: [{
+                        type: 'text',
+                        text: `Error: ${err instanceof Error ? err.message : String(err)}`,
+                    }],
+                isError: true,
+            };
+        }
+    });
+}
+//# sourceMappingURL=tools.js.map