@axboot-mcp/mcp-server 1.0.0

package/src/features/store-features.ts

@@ -0,0 +1,232 @@
+/**
+ * Store 피처/태그 정의
+ * 각 피처는 State와 Action을 포함
+ */
+
+export interface StoreFeature {
+  name: string;
+  description: string;
+  keywords: string[]; // 자연어 분석용 키워드
+  states: string[];
+  actions: string[];
+}
+
+export const FEATURES: Record<string, StoreFeature> = {
+  // 기본 기능
+  LIST: {
+    name: '리스트',
+    description: '기본 리스트 표시',
+    keywords: ['리스트', '목록', '목록보기', '조회', '표시', '나열'],
+    states: ['listData', 'listPage', 'listSpinning'],
+    actions: ['callListApi', 'changeListPage'],
+  },
+
+  SEARCH: {
+    name: '검색',
+    description: '검색 기능',
+    keywords: ['검색', '찾기', '필터', '서치'],
+    states: ['searchValue'],
+    actions: ['onSearch'],
+  },
+
+  // 선택 기능
+  SELECTED_ITEM: {
+    name: '선택 아이템',
+    description: '선택된 항목 저장',
+    keywords: ['선택', '클릭', '선택된', '하나 선택', '단일 선택'],
+    states: ['selectedItem'],
+    actions: ['setSelectedItem'],
+  },
+
+  CHECKBOX: {
+    name: '체크박스',
+    description: '다중 선택 체크박스',
+    keywords: ['체크', '체크박스', '다중 선택', '여러개', '복수 선택', 'checkbox'],
+    states: ['checkedRowKeys'],
+    actions: ['setCheckedRowKeys'],
+  },
+
+  // 상세 영역
+  DETAIL_PANEL: {
+    name: '상세 영역',
+    description: '별도의 상세 표시 영역',
+    keywords: ['상세', '디테일', '상세보기', 'detail', '우측 상세', '오른쪽 상세'],
+    states: ['detail', 'detailSpinning'],
+    actions: ['setDetail'],
+  },
+
+  DETAIL_API: {
+    name: '상세 조회 API',
+    description: '상세 조회 API 호출',
+    keywords: ['상세조회', '상세 api', '디테일 조회', '상세 정보 가져오기'],
+    states: ['detailSpinning'],
+    actions: ['callDetailApi'],
+  },
+
+  // CRUD 기능
+  SAVE: {
+    name: '저장',
+    description: '저장/수정 기능',
+    keywords: ['저장', '수정', '등록', '추가', 'create', 'update', 'save'],
+    states: ['saveRequestValue', 'saveSpinning'],
+    actions: ['callSaveApi'],
+  },
+
+  DELETE: {
+    name: '삭제',
+    description: '삭제 기능',
+    keywords: ['삭제', '제거', 'delete', 'remove'],
+    states: ['deleteSpinning'],
+    actions: ['callDeleteApi'],
+  },
+
+  // UI 기능
+  MODAL: {
+    name: '모달',
+    description: '모달/팝업 창',
+    keywords: ['모달', '팝업', 'modal', 'popup', '다이얼로그', 'dialog'],
+    states: ['modalOpen'],
+    actions: ['setModalOpen'],
+  },
+
+  EXCEL_DOWNLOAD: {
+    name: '엑셀 다운로드',
+    description: '엑셀 다운로드 기능',
+    keywords: ['엑셀', 'excel', '다운로드', '내보내기', 'export'],
+    states: ['excelSpinning'],
+    actions: ['callExcelDownloadApi'],
+  },
+
+  // 특수 패턴
+  TREE: {
+    name: '트리',
+    description: '트리 구조',
+    keywords: ['트리', 'tree', '계층', '폴더', '카테고리', '메뉴'],
+    states: ['treeData', 'treeSpinning', 'expandedKeys'],
+    actions: ['callTreeApi', 'setExpandedKeys'],
+  },
+
+  REORDER: {
+    name: '재정렬',
+    description: '드래그 앤 드롭 재정렬',
+    keywords: ['순서', '재정렬', '드래그', '정렬', '위치 변경', 'reorder', 'drag', 'drop'],
+    states: ['isReordered'],
+    actions: ['onDrop'],
+  },
+
+  DASHBOARD: {
+    name: '대시보드',
+    description: '대시보드 요약 정보',
+    keywords: ['대시보드', '요약', 'summary', '통계', '집계'],
+    states: ['summaryData', 'summarySpinning'],
+    actions: ['callSummaryApi'],
+  },
+
+  TAB: {
+    name: '탭 전환',
+    description: '탭 전환 기능',
+    keywords: ['탭', 'tab', '전환'],
+    states: ['activeTabKey'],
+    actions: ['setActiveTabKey'],
+  },
+};
+
+/**
+ * Type별 피처 조합
+ */
+export const TYPE_FEATURES: Record<number, string[]> = {
+  1: ['LIST', 'SEARCH', 'SELECTED_ITEM', 'SAVE', 'CHECKBOX'],
+  2: ['LIST', 'SEARCH', 'SELECTED_ITEM', 'DETAIL_PANEL', 'MODAL', 'DELETE', 'CHECKBOX'],
+  3: ['TREE', 'SAVE'],
+  4: ['LIST', 'DASHBOARD', 'TAB'],
+  5: ['LIST'],
+  6: ['LIST', 'REORDER'],
+  7: ['LIST', 'SEARCH', 'SELECTED_ITEM', 'DETAIL_PANEL', 'MODAL', 'DELETE', 'SAVE', 'EXCEL_DOWNLOAD', 'CHECKBOX'],
+  8: ['LIST', 'SELECTED_ITEM', 'CHECKBOX', 'EXCEL_DOWNLOAD'],
+  9: ['LIST', 'SELECTED_ITEM', 'DETAIL_PANEL', 'MODAL', 'DETAIL_API'],
+  10: ['LIST', 'SELECTED_ITEM', 'EXCEL_DOWNLOAD'],
+};
+
+/**
+ * Type 정보
+ */
+export interface TypeInfo {
+  type: number;
+  name: string;
+  description: string;
+  features: string[];
+  useCases: string[];
+}
+
+export const TYPE_INFOS: TypeInfo[] = [
+  {
+    type: 1,
+    name: '기본 리스트 + 상세',
+    description: '선택된 아이템의 상세 정보 표시, 저장/수정 지원',
+    features: TYPE_FEATURES[1],
+    useCases: ['회원 목록', '상품 목록', '쿠폰 목록'],
+  },
+  {
+    type: 2,
+    name: '마스터-디테일 + 모달 + 삭제',
+    description: '왼쪽 리스트, 오른쪽 상세, 모달, 삭제 기능 (B2B 패턴)',
+    features: TYPE_FEATURES[2],
+    useCases: ['B2B 상품', '견적 상담', '구독 관리'],
+  },
+  {
+    type: 3,
+    name: '트리 기반',
+    description: '트리 구조 데이터, 펼치기/접기, 저장 지원',
+    features: TYPE_FEATURES[3],
+    useCases: ['카테고리 관리', '메뉴 관리', '조직도'],
+  },
+  {
+    type: 4,
+    name: '대시보드',
+    description: '여러 개의 리스트와 요약 정보, 탭 전환',
+    features: TYPE_FEATURES[4],
+    useCases: ['회원 대시보드', '주문 대시보드', '매출 대시보드'],
+  },
+  {
+    type: 5,
+    name: '단순 리스트',
+    description: '최소한의 기능만 있는 단순 리스트',
+    features: TYPE_FEATURES[5],
+    useCases: ['참조 데이터 조회', '드롭다운 목록'],
+  },
+  {
+    type: 6,
+    name: '재정렬 가능 리스트',
+    description: '드래그 앤 드롭으로 순서 변경 가능',
+    features: TYPE_FEATURES[6],
+    useCases: ['팝업 메뉴', '배너 순서', '메뉴 순서'],
+  },
+  {
+    type: 7,
+    name: '마스터-디테일 + 모달 + 삭제 + 엑셀',
+    description: '왼쪽 리스트, 오른쪽 상세, 모달, 삭제, 엑셀 다운로드',
+    features: TYPE_FEATURES[7],
+    useCases: ['B2B 견적 상담', '상담 관리', '주문 관리'],
+  },
+  {
+    type: 8,
+    name: '리스트 + 선택 + 엑셀 다운로드',
+    description: '선택 아이템, 체크박스, 엑셀 다운로드 (상세 없음)',
+    features: TYPE_FEATURES[8],
+    useCases: ['주문 전체 조회', '결제 조회', '배송 조회'],
+  },
+  {
+    type: 9,
+    name: '마스터-디테일 + 모달 + 상세조회 API',
+    description: '왼쪽 리스트, 오른쪽 상세, 모달, 상세 조회 API 호출',
+    features: TYPE_FEATURES[9],
+    useCases: ['직배송 구독', '상담 내역', '주문 상세'],
+  },
+  {
+    type: 10,
+    name: '마스터-디테일 + 엑셀 다운로드',
+    description: '선택된 행 표시, 엑셀 다운로드 (상세/모달 없음)',
+    features: TYPE_FEATURES[10],
+    useCases: ['상품 그룹 마스터', '분류 관리', '카테고리 마스터'],
+  },
+];

package/src/handlers/analyze-requirements.ts

@@ -0,0 +1,403 @@
+import { FEATURES, TYPE_FEATURES, TYPE_INFOS, TypeInfo } from '../features/store-features.js';
+import {
+  getStoreTypeInfo,
+  getAllFields,
+  suggestStoreType,
+  getContextualDocumentation
+} from '../docs/index.js';
+
+/**
+ * 요구사항 분석 결과
+ */
+export interface RequirementsAnalysis {
+  success: boolean;
+  requirements: string;
+  extractedFeatures: string[];
+  matchedTypes: TypeMatch[];
+  recommendedType?: TypeMatch;
+  canUseExistingType: boolean;
+  isComplexRequest: boolean;
+  contextualDocs?: string;
+  relevantDocs?: string[];
+}
+
+/**
+ * 타입 매칭 결과
+ */
+export interface TypeMatch {
+  type: number;
+  name: string;
+  description: string;
+  matchScore: number;
+  matchedFeatures: string[];
+  missingFeatures: string[];
+  extraFeatures: string[];
+}
+
+/**
+ * 자연어 요구사항을 분석하여 필요한 피처 추출
+ */
+export async function analyzeRequirements(args: {
+  requirements: string;
+}): Promise<{
+  content: Array<{ type: string; text: string }>;
+}> {
+  const { requirements } = args;
+
+  try {
+    // 1. 요구사항에서 피처 추출
+    const extractedFeatures = extractFeaturesFromRequirements(requirements);
+
+    // 2. 각 타입과 매칭 점수 계산
+    const matchedTypes = matchTypes(extractedFeatures);
+
+    // 3. 가장 적합한 타입 추천
+    const recommendedType = findBestMatch(matchedTypes);
+
+    // 4. 기존 타입 사용 가능 여부 판단 (매칭 점수 0.8 이상이면 사용 가능)
+    const canUseExistingType = recommendedType ? recommendedType.matchScore >= 0.8 : false;
+
+    // 5. 복잡한 요청 여부 판단 및 문서 컨텍스트 생성
+    const matchScore = recommendedType?.matchScore || 0;
+    const docsContext = getContextualDocumentation(
+      matchScore,
+      extractedFeatures,
+      recommendedType?.type
+    );
+
+    const analysis: RequirementsAnalysis = {
+      success: true,
+      requirements,
+      extractedFeatures,
+      matchedTypes,
+      recommendedType,
+      canUseExistingType,
+      isComplexRequest: docsContext.isComplex,
+      contextualDocs: docsContext.isComplex ? docsContext.context : undefined,
+      relevantDocs: docsContext.relevantDocs,
+    };
+
+    return {
+      content: [
+        {
+          type: 'text',
+          text: JSON.stringify(analysis, null, 2),
+        },
+      ],
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: 'text',
+          text: JSON.stringify({
+            success: false,
+            error: error instanceof Error ? error.message : String(error),
+          }),
+        },
+      ],
+    };
+  }
+}
+
+/**
+ * 요구사항에서 피처 추출 (키워드 매칭)
+ */
+export function extractFeaturesFromRequirements(requirements: string): string[] {
+  const extracted: string[] = [];
+  const lowerRequirements = requirements.toLowerCase();
+
+  for (const [featureKey, feature] of Object.entries(FEATURES)) {
+    // 키워드 매칭
+    for (const keyword of feature.keywords) {
+      if (lowerRequirements.includes(keyword.toLowerCase())) {
+        if (!extracted.includes(featureKey)) {
+          extracted.push(featureKey);
+        }
+        break;
+      }
+    }
+  }
+
+  // 항상 LIST는 기본으로 포함 (명시적 언급이 없어도)
+  if (!extracted.includes('LIST')) {
+    extracted.unshift('LIST');
+  }
+
+  return extracted;
+}
+
+/**
+ * 추출된 피처와 각 타입을 매칭하여 점수 계산
+ */
+export function matchTypes(extractedFeatures: string[]): TypeMatch[] {
+  const matches: TypeMatch[] = [];
+
+  for (const typeInfo of TYPE_INFOS) {
+    const typeFeatures = TYPE_FEATURES[typeInfo.type] || [];
+
+    // 일치하는 피처
+    const matchedFeatures = extractedFeatures.filter((f) => typeFeatures.includes(f));
+
+    // 부족한 피처 (요구사항에는 있는데 타입에는 없는)
+    const missingFeatures = extractedFeatures.filter((f) => !typeFeatures.includes(f));
+
+    // 추가 피처 (타입에는 있는데 요구사항에는 없는)
+    const extraFeatures = typeFeatures.filter((f) => !extractedFeatures.includes(f));
+
+    // 매칭 점수 계산
+    // - 일치하는 피처: +1점
+    // - 부족한 피처: -0.5점
+    // - 추가 피처: -0.2점 (불필요한 기능이 있음)
+    let matchScore = 0;
+    matchScore += matchedFeatures.length * 1;
+    matchScore += missingFeatures.length * -0.5;
+    matchScore += extraFeatures.length * -0.1;
+
+    // 정규화 (0-1 사이)
+    matchScore = Math.max(0, Math.min(1, (matchScore + 1) / (extractedFeatures.length + 1)));
+
+    matches.push({
+      type: typeInfo.type,
+      name: typeInfo.name,
+      description: typeInfo.description,
+      matchScore,
+      matchedFeatures,
+      missingFeatures,
+      extraFeatures,
+    });
+  }
+
+  // 매칭 점수순 정렬
+  return matches.sort((a, b) => b.matchScore - a.matchScore);
+}
+
+/**
+ * 가장 적합한 타입 찾기
+ */
+export function findBestMatch(matchedTypes: TypeMatch[]): TypeMatch | undefined {
+  if (matchedTypes.length === 0) return undefined;
+
+  const best = matchedTypes[0];
+
+  // 최소 매칭 기준: 적어도 하나의 피처는 일치해야 함
+  if (best.matchedFeatures.length === 0) {
+    return undefined;
+  }
+
+  return best;
+}
+
+/**
+ * 동적 Store 생성을 위한 피처 조합 추천
+ * 기존 타입으로 커버되지 않을 때 사용
+ */
+export function suggestFeatureCombination(extractedFeatures: string[]): {
+  features: string[];
+  recommendedTemplate: string;
+} {
+  // 기본 템플릿 (Type 1)
+  let recommendedType = 1;
+  let bestScore = 0;
+
+  // 가장 가까운 타입 찾기
+  for (const typeInfo of TYPE_INFOS) {
+    const typeFeatures = TYPE_FEATURES[typeInfo.type] || [];
+    const intersection = extractedFeatures.filter((f) => typeFeatures.includes(f));
+    const score = intersection.length;
+
+    if (score > bestScore) {
+      bestScore = score;
+      recommendedType = typeInfo.type;
+    }
+  }
+
+  return {
+    features: extractedFeatures,
+    recommendedTemplate: `type${recommendedType}`,
+  };
+}
+
+/**
+ * docs/patterns.json 기반 정밀 타입 매칭
+ * 기존 키워드 매칭보다 더 정확한 타입 추천 제공
+ */
+export function matchTypesWithJsonPatterns(extractedFeatures: string[]): TypeMatch[] {
+  const matches: TypeMatch[] = [];
+
+  // types 1-12 순회
+  for (let typeNum = 1; typeNum <= 12; typeNum++) {
+    const typeInfo = getStoreTypeInfo(typeNum);
+
+    if (!typeInfo) {
+      // 패턴 정보가 없는 타�은 기본 TYPE_INFOS 사용
+      const baseTypeInfo = TYPE_INFOS.find(t => t.type === typeNum);
+      if (baseTypeInfo) {
+        const typeFeatures = TYPE_FEATURES[baseTypeInfo.type] || [];
+        const matchedFeatures = extractedFeatures.filter((f) => typeFeatures.includes(f));
+        const missingFeatures = extractedFeatures.filter((f) => !typeFeatures.includes(f));
+        const extraFeatures = typeFeatures.filter((f) => !extractedFeatures.includes(f));
+
+        let matchScore = matchedFeatures.length * 1;
+        matchScore += missingFeatures.length * -0.5;
+        matchScore += extraFeatures.length * -0.1;
+        matchScore = Math.max(0, Math.min(1, (matchScore + 1) / (extractedFeatures.length + 1)));
+
+        matches.push({
+          type: baseTypeInfo.type,
+          name: baseTypeInfo.name,
+          description: baseTypeInfo.description,
+          matchScore,
+          matchedFeatures,
+          missingFeatures,
+          extraFeatures,
+        });
+      }
+      continue;
+    }
+
+    // JSON 패턴에서 필드 정보 추출
+    const allFields = [
+      ...typeInfo.metadata.required,
+      ...typeInfo.metadata.optional,
+      ...typeInfo.states.required,
+      ...typeInfo.states.optional,
+      ...typeInfo.actions.required,
+      ...typeInfo.actions.optional,
+    ];
+
+    // 필드 이름을 피처 키워드와 매칭
+    const matchedFeatures: string[] = [];
+    const allFieldsLower = allFields.map(f => f.toLowerCase());
+
+    for (const feature of extractedFeatures) {
+      const featureLower = feature.toLowerCase();
+      // 직접 필드명 매칭
+      if (allFieldsLower.some(field => field.includes(featureLower))) {
+        matchedFeatures.push(feature);
+        continue;
+      }
+
+      // 특수 매칭 규칙
+      switch (feature) {
+        case 'LIST':
+          if (allFieldsLower.some(f => f.includes('list'))) matchedFeatures.push(feature);
+          break;
+        case 'SEARCH':
+          if (allFieldsLower.some(f => f.includes('request'))) matchedFeatures.push(feature);
+          break;
+        case 'DETAIL':
+        case 'DETAIL_PANEL':
+          if (allFieldsLower.some(f => f.includes('detail') || f.includes('save'))) matchedFeatures.push(feature);
+          break;
+        case 'MODAL':
+          if (allFieldsLower.some(f => f.includes('modal'))) matchedFeatures.push(feature);
+          break;
+        case 'SAVE':
+          if (allFieldsLower.some(f => f.includes('save'))) matchedFeatures.push(feature);
+          break;
+        case 'DELETE':
+          if (allFieldsLower.some(f => f.includes('delete'))) matchedFeatures.push(feature);
+          break;
+        case 'EXCEL':
+        case 'EXCEL_DOWNLOAD':
+          if (allFieldsLower.some(f => f.includes('excel'))) matchedFeatures.push(feature);
+          break;
+        case 'CHECKBOX':
+          if (allFieldsLower.some(f => f.includes('checked') || f.includes('check'))) matchedFeatures.push(feature);
+          break;
+        case 'TREE':
+          if (allFieldsLower.some(f => f.includes('tree'))) matchedFeatures.push(feature);
+          break;
+      }
+    }
+
+    const missingFeatures = extractedFeatures.filter((f) => !matchedFeatures.includes(f));
+    const extraFeatures: string[] = [];
+
+    // 매칭 점수 계산 (JSON 기반 가중치)
+    let matchScore = 0;
+    matchScore += matchedFeatures.length * 1.2; // JSON 기반 매칭에 더 높은 가중치
+    matchScore += missingFeatures.length * -0.3;
+    matchScore = Math.max(0, Math.min(1, (matchScore + 1) / (extractedFeatures.length + 1)));
+
+    matches.push({
+      type: typeNum,
+      name: typeInfo.name || `Type ${typeNum}`,
+      description: typeInfo.description || '',
+      matchScore,
+      matchedFeatures,
+      missingFeatures,
+      extraFeatures,
+    });
+  }
+
+  return matches.sort((a, b) => b.matchScore - a.matchScore);
+}
+
+/**
+ * 요구사항으로부터 최적의 Store 타입 추천 (JSON 패턴 활용)
+ */
+export function recommendStoreTypeFromRequirements(requirements: string): {
+  type: number;
+  name: string;
+  description: string;
+  confidence: number;
+} {
+  const extractedFeatures = extractFeaturesFromRequirements(requirements);
+  const matches = matchTypesWithJsonPatterns(extractedFeatures);
+
+  if (matches.length === 0 || matches[0].matchedFeatures.length === 0) {
+    return {
+      type: 1,
+      name: 'Basic List',
+      description: '단순 조회 페이지',
+      confidence: 0.5,
+    };
+  }
+
+  const best = matches[0];
+  return {
+    type: best.type,
+    name: best.name,
+    description: best.description,
+    confidence: best.matchScore,
+  };
+}
+
+/**
+ * 특정 Store 타입에 필요한 필드 정보 반환
+ */
+export function getStoreTypeFields(type: number): {
+  metadata: { required: string[]; optional: string[] };
+  states: { required: string[]; optional: string[] };
+  actions: { required: string[]; optional: string[] };
+  subscribeSelector: string[];
+} {
+  const typeInfo = getStoreTypeInfo(type);
+
+  if (!typeInfo) {
+    return {
+      metadata: { required: [], optional: [] },
+      states: { required: [], optional: [] },
+      actions: { required: [], optional: [] },
+      subscribeSelector: [],
+    };
+  }
+
+  return {
+    metadata: {
+      required: typeInfo.metadata.required || [],
+      optional: typeInfo.metadata.optional || [],
+    },
+    states: {
+      required: typeInfo.states.required || [],
+      optional: typeInfo.states.optional || [],
+    },
+    actions: {
+      required: typeInfo.actions.required || [],
+      optional: typeInfo.actions.optional || [],
+    },
+    subscribeSelector: typeInfo.subscribePattern?.selector || [],
+  };
+}