@axboot-mcp/mcp-server 1.0.0

package/src/docs/loader.ts

@@ -0,0 +1,568 @@
+import * as fs from 'fs';
+import * as path from 'path';
+
+// 현재 파일 위치 기준으로 docs 폴더 경로 계산
+// 빌드 후 dist/docs 폴더를 참조
+// loader.js 자체가 dist/docs에 있으므로 현재 디렉토리를 반환
+function getDocsDir(): string {
+  // 현재 모듈의 경로를 동적으로 계산
+  const callerPath = new Error().stack?.split('\n')[2]?.match(/\((.*?):\d+:\d+\)/)?.[1];
+  if (callerPath) {
+    const callerDir = path.dirname(callerPath);
+    // loader.js가 dist/docs에 있으므로 현재 디렉토리를 반환
+    return callerDir;
+  }
+  // fallback: 현재 작업 디렉토리 기준
+  return path.join(process.cwd(), 'dist', 'docs');
+}
+
+const DOCS_DIR = getDocsDir();
+
+export interface DocsContent {
+  patterns: string;
+  rules: string;
+  usageGuide: string;
+  quickStart: string;
+  requirementsAnalysis: string;
+  practicalExamples: string;
+  troubleshooting: string;
+  typeSelection: string;
+  readme: string;
+}
+
+export interface LoadedDocs {
+  patternsJson: any;
+  rulesJson: any;
+  markdown: DocsContent;
+  fullContext: string;
+}
+
+/**
+ * Load all documentation for store generation
+ */
+export function loadDocs(): LoadedDocs {
+  const docsDir = DOCS_DIR;
+
+  // Load JSON files
+  const patternsJson = JSON.parse(
+    fs.readFileSync(path.join(docsDir, 'patterns.json'), 'utf-8')
+  );
+
+  const rulesJson = JSON.parse(
+    fs.readFileSync(path.join(docsDir, 'rules.json'), 'utf-8')
+  );
+
+  // Load markdown files
+  const patterns = fs.readFileSync(
+    path.join(docsDir, 'store-pattern-analysis.md'),
+    'utf-8'
+  );
+
+  const rules = fs.readFileSync(
+    path.join(docsDir, 'store-patterns-rules.md'),
+    'utf-8'
+  );
+
+  const usageGuide = fs.readFileSync(
+    path.join(docsDir, 'store-patterns-usage-guide.md'),
+    'utf-8'
+  );
+
+  const quickStart = fs.readFileSync(
+    path.join(docsDir, 'quick-start.md'),
+    'utf-8'
+  );
+
+  const requirementsAnalysis = fs.readFileSync(
+    path.join(docsDir, 'requirements-analysis-guide.md'),
+    'utf-8'
+  );
+
+  const practicalExamples = fs.readFileSync(
+    path.join(docsDir, 'practical-examples.md'),
+    'utf-8'
+  );
+
+  const troubleshooting = fs.readFileSync(
+    path.join(docsDir, 'troubleshooting.md'),
+    'utf-8'
+  );
+
+  const typeSelection = fs.readFileSync(
+    path.join(docsDir, 'type-selection-guide.md'),
+    'utf-8'
+  );
+
+  const readme = fs.readFileSync(
+    path.join(docsDir, 'README.md'),
+    'utf-8'
+  );
+
+  // Build full context for LLM
+  const fullContext = buildFullContext({
+    patterns,
+    rules,
+    usageGuide,
+    quickStart,
+    requirementsAnalysis,
+    practicalExamples,
+    troubleshooting,
+    typeSelection,
+    readme
+  });
+
+  return {
+    patternsJson,
+    rulesJson,
+    markdown: {
+      patterns,
+      rules,
+      usageGuide,
+      quickStart,
+      requirementsAnalysis,
+      practicalExamples,
+      troubleshooting,
+      typeSelection,
+      readme
+    },
+    fullContext
+  };
+}
+
+/**
+ * Get store type information from patterns.json
+ */
+export function getStoreTypeInfo(type: number): any {
+  const docs = loadDocs();
+  const typeKey = type.toString();
+  return docs.patternsJson.storeTypes[typeKey] || null;
+}
+
+/**
+ * Get field combinations for store generation
+ */
+export function getFieldCombinations(): any {
+  const docs = loadDocs();
+  return docs.patternsJson.fieldCombinations;
+}
+
+/**
+ * Get initial values for createStates
+ */
+export function getInitialValues(type?: number): any {
+  const docs = loadDocs();
+  const common = docs.patternsJson.initialValues.common;
+  const typeSpecific = type
+    ? docs.patternsJson.initialValues.typeSpecific[`type${type}`] || {}
+    : {};
+  return { ...common, ...typeSpecific };
+}
+
+/**
+ * Build full documentation context for LLM prompt injection
+ */
+function buildFullContext(markdown: DocsContent): string {
+  return `
+# NH-FE-B Store Pattern Documentation
+
+## 1. Pattern Analysis
+${markdown.patterns}
+
+## 2. Rules and Constraints
+${markdown.rules}
+
+## 3. Usage Guide
+${markdown.usageGuide}
+
+## 4. Quick Start Guide
+${markdown.quickStart}
+
+## 5. Requirements Analysis Guide
+${markdown.requirementsAnalysis}
+
+## 6. Practical Examples
+${markdown.practicalExamples}
+
+## 7. Troubleshooting
+${markdown.troubleshooting}
+
+## 8. Type Selection Guide
+${markdown.typeSelection}
+
+## 9. Documentation Index
+${markdown.readme}
+`;
+}
+
+/**
+ * Get metadata fields for a specific store type
+ */
+export function getMetadataFields(type: number): {
+  required: string[];
+  optional: string[];
+} {
+  const typeInfo = getStoreTypeInfo(type);
+  if (!typeInfo) {
+    return { required: [], optional: [] };
+  }
+  return {
+    required: typeInfo.metadata.required || [],
+    optional: typeInfo.metadata.optional || []
+  };
+}
+
+/**
+ * Get states fields for a specific store type
+ */
+export function getStatesFields(type: number): {
+  required: string[];
+  optional: string[];
+} {
+  const typeInfo = getStoreTypeInfo(type);
+  if (!typeInfo) {
+    return { required: [], optional: [] };
+  }
+  return {
+    required: typeInfo.states.required || [],
+    optional: typeInfo.states.optional || []
+  };
+}
+
+/**
+ * Get actions for a specific store type
+ */
+export function getActions(type: number): {
+  required: string[];
+  optional: string[];
+} {
+  const typeInfo = getStoreTypeInfo(type);
+  if (!typeInfo) {
+    return { required: [], optional: [] };
+  }
+  return {
+    required: typeInfo.actions.required || [],
+    optional: typeInfo.actions.optional || []
+  };
+}
+
+/**
+ * Get store type fields (metadata, states, actions, subscribe)
+ */
+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 || [],
+  };
+}
+
+/**
+ * Get subscribe selector pattern for a specific store type
+ */
+export function getSubscribeSelector(type: number): string[] {
+  const typeInfo = getStoreTypeInfo(type);
+  if (!typeInfo) {
+    return [];
+  }
+  return typeInfo.subscribePattern?.selector || [];
+}
+
+/**
+ * Get all field definitions
+ */
+export function getAllFields(): {
+  metadata: Record<string, any>;
+  states: Record<string, any>;
+  actions: Record<string, any>;
+} {
+  const docs = loadDocs();
+  return docs.patternsJson.fields;
+}
+
+/**
+ * Get validation rules
+ */
+export function getValidationRules(): any {
+  const docs = loadDocs();
+  return docs.rulesJson;
+}
+
+/**
+ * Get forbidden patterns for validation
+ */
+export function getForbiddenPatterns(): any[] {
+  const docs = loadDocs();
+  return docs.rulesJson.forbiddenPatterns || [];
+}
+
+/**
+ * Get checklist for store generation verification
+ */
+export function getChecklist(): any {
+  const docs = loadDocs();
+  return docs.rulesJson.checklist || {};
+}
+
+/**
+ * Get required imports for store
+ */
+export function getRequiredImports(): any[] {
+  const docs = loadDocs();
+  return docs.rulesJson.requiredImports || [];
+}
+
+/**
+ * Get naming rules
+ */
+export function getNamingRules(): any {
+  const docs = loadDocs();
+  return docs.rulesJson.namingRules || {};
+}
+
+/**
+ * Get implementation rules (e.g., callListApi template)
+ */
+export function getImplementationRules(): any {
+  const docs = loadDocs();
+  return docs.rulesJson.implementationRules || {};
+}
+
+/**
+ * Get field order for organization
+ */
+export function getFieldOrder(): any {
+  const docs = loadDocs();
+  return docs.rulesJson.fieldOrder || {};
+}
+
+/**
+ * Get dependencies between fields
+ */
+export function getDependencies(): any {
+  const docs = loadDocs();
+  return docs.rulesJson.dependencies || {};
+}
+
+/**
+ * Suggest store type based on feature keywords
+ */
+export function suggestStoreType(features: string[]): number {
+  const docs = loadDocs();
+  const storeTypes = docs.patternsJson.storeTypes;
+
+  // Count matching features for each type
+  const typeScores: Record<number, number> = {};
+
+  for (const entry of Object.entries(storeTypes)) {
+    const typeKey = entry[0] as string;
+    const typeInfo = entry[1] as any;
+    const typeNum = parseInt(typeKey, 10);
+    const allFields = [
+      ...typeInfo.metadata.required,
+      ...typeInfo.metadata.optional,
+      ...typeInfo.actions.required,
+      ...typeInfo.actions.optional
+    ];
+
+    // Count how many features match this type
+    let score = 0;
+    for (const feature of features) {
+      if (allFields.some((field: string) =>
+        field.toLowerCase().includes(feature.toLowerCase())
+      )) {
+        score++;
+      }
+    }
+
+    typeScores[typeNum] = score;
+  }
+
+  // Return type with highest score, default to 1
+  let maxScore = 0;
+  let suggestedType = 1;
+
+  for (const entry of Object.entries(typeScores)) {
+    const type = entry[0] as string;
+    const score = entry[1] as number;
+    if (score > maxScore) {
+      maxScore = score;
+      suggestedType = parseInt(type, 10);
+    }
+  }
+
+  return suggestedType;
+}
+
+// Export a singleton instance
+let cachedDocs: LoadedDocs | null = null;
+
+export function getCachedDocs(): LoadedDocs {
+  if (!cachedDocs) {
+    cachedDocs = loadDocs();
+  }
+  return cachedDocs;
+}
+
+/**
+ * 복잡한 요청 여부 판단
+ * JSON 매칭 점수가 임계값 미만이거나, 특정 조건에 해당하면 복잡한 요청으로 간주
+ */
+export function isComplexRequest(matchScore: number, extractedFeatures: string[]): boolean {
+  // 매칭 점수가 낮으면 복잡한 요청
+  if (matchScore < 0.6) {
+    return true;
+  }
+
+  // 피처가 많으면 복잡한 요청 (5개 이상)
+  if (extractedFeatures.length >= 5) {
+    return true;
+  }
+
+  // 특정 피처 조합이면 복잡한 요청
+  const complexCombinations = [
+    ['TREE', 'DASHBOARD'],
+    ['MODAL', 'TREE', 'DETAIL_PANEL'],
+    ['EXCEL_DOWNLOAD', 'DELETE', 'CHECKBOX'],
+  ];
+
+  for (const combo of complexCombinations) {
+    if (combo.every(f => extractedFeatures.includes(f))) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+/**
+ * 복잡한 요청에 필요한 문서 컨텍스트 반환
+ */
+export function getComplexRequestContext(extractedFeatures: string[]): {
+  context: string;
+  relevantDocs: string[];
+  isComplex: boolean;
+} {
+  const docs = getCachedDocs();
+  const relevantDocs: string[] = [];
+  let context = '';
+
+  // 항상 포함할 기본 문서
+  relevantDocs.push('typeSelection');
+  relevantDocs.push('requirementsAnalysis');
+  context += `
+## 타입 선택 가이드
+${docs.markdown.typeSelection}
+
+## 요구사항 분석 가이드
+${docs.markdown.requirementsAnalysis}
+`;
+
+  // 피처별 관련 문서 추가
+  if (extractedFeatures.includes('TREE')) {
+    relevantDocs.push('practicalExamples');
+    context += `
+## 실전 예제 (트리 관련)
+${docs.markdown.practicalExamples.split('## ')[2] || ''}
+`;
+  }
+
+  if (extractedFeatures.includes('DASHBOARD')) {
+    relevantDocs.push('practicalExamples');
+    context += `
+## 실전 예제 (대시보드 관련)
+${docs.markdown.practicalExamples.split('## ')[4] || ''}
+`;
+  }
+
+  if (extractedFeatures.includes('EXCEL_DOWNLOAD')) {
+    relevantDocs.push('troubleshooting');
+    context += `
+## 엑셀 다운로드 관련 문제 해결
+${docs.markdown.troubleshooting.split('### 2.2')[0] || ''}
+`;
+  }
+
+  // 문제가 있을 경우 트러블슈팅 추가
+  relevantDocs.push('troubleshooting');
+  context += `
+## 문제 해결 가이드
+${docs.markdown.troubleshooting}
+`;
+
+  return { context, relevantDocs, isComplex: true };
+}
+
+/**
+ * 단순 요청에 필요한 문서 컨텍스트 반환
+ */
+export function getSimpleRequestContext(recommendedType: number): {
+  context: string;
+  relevantDocs: string[];
+  isComplex: boolean;
+} {
+  const docs = getCachedDocs();
+  const relevantDocs: string[] = ['quickStart'];
+
+  const context = `
+## 빠른 시작 가이드
+${docs.markdown.quickStart}
+
+## 추천 타입: Type ${recommendedType}
+${getStoreTypeInfo(recommendedType)?.description || ''}
+
+## 실전 예제
+${docs.markdown.practicalExamples}
+`;
+
+  return { context, relevantDocs, isComplex: false };
+}
+
+/**
+ * 상황별 적절한 문서 반환
+ */
+export function getContextualDocumentation(
+  matchScore: number,
+  extractedFeatures: string[],
+  recommendedType?: number
+): {
+  context: string;
+  relevantDocs: string[];
+  isComplex: boolean;
+} {
+  const isComplex = isComplexRequest(
+    matchScore,
+    extractedFeatures
+  );
+
+  if (isComplex) {
+    return getComplexRequestContext(extractedFeatures);
+  }
+
+  return getSimpleRequestContext(recommendedType || 1);
+}