metadatafy 1.0.1 → 1.0.3

package/dist/chunk-ECKCIPM5.js

@@ -1,1329 +0,0 @@
-import ts3 from 'typescript';
-import * as path2 from 'path';
-import * as fs from 'fs';
-import * as crypto from 'crypto';
-import { glob } from 'glob';
-import * as fs3 from 'fs/promises';
-
-// src/core/config.ts
-var DEFAULT_FILE_TYPE_MAPPING = {
-  // Next.js App Router
-  "app/**/page.tsx": "route",
-  "app/**/page.ts": "route",
-  "app/**/layout.tsx": "route",
-  "app/**/layout.ts": "route",
-  "app/**/route.tsx": "api",
-  "app/**/route.ts": "api",
-  "app/api/**/*.ts": "api",
-  "app/api/**/*.tsx": "api",
-  // Pages Router (레거시)
-  "pages/**/*.tsx": "route",
-  "pages/**/*.ts": "route",
-  "pages/api/**/*.ts": "api",
-  // Components
-  "components/**/*.tsx": "component",
-  "components/**/*.ts": "component",
-  "src/components/**/*.tsx": "component",
-  "src/components/**/*.ts": "component",
-  // Hooks
-  "hooks/**/*.ts": "hook",
-  "hooks/**/*.tsx": "hook",
-  "src/hooks/**/*.ts": "hook",
-  "src/hooks/**/*.tsx": "hook",
-  // Services
-  "services/**/*.ts": "service",
-  "src/services/**/*.ts": "service",
-  // Utilities
-  "lib/**/*.ts": "utility",
-  "src/lib/**/*.ts": "utility",
-  "utils/**/*.ts": "utility",
-  "src/utils/**/*.ts": "utility",
-  // Database
-  "supabase/migrations/*.sql": "table",
-  "prisma/migrations/**/*.sql": "table"
-};
-var DEFAULT_INCLUDE_PATTERNS = [
-  "app/**/*.{ts,tsx}",
-  "pages/**/*.{ts,tsx}",
-  "components/**/*.{ts,tsx}",
-  "hooks/**/*.{ts,tsx}",
-  "services/**/*.ts",
-  "lib/**/*.ts",
-  "utils/**/*.ts",
-  "src/**/*.{ts,tsx}",
-  "supabase/migrations/*.sql"
-];
-var DEFAULT_EXCLUDE_PATTERNS = [
-  "**/node_modules/**",
-  "**/.next/**",
-  "**/dist/**",
-  "**/*.test.{ts,tsx}",
-  "**/*.spec.{ts,tsx}",
-  "**/__tests__/**",
-  "**/*.d.ts",
-  "**/coverage/**"
-];
-function createDefaultConfig(overrides = {}) {
-  return {
-    projectId: overrides.projectId || "default",
-    include: overrides.include || DEFAULT_INCLUDE_PATTERNS,
-    exclude: overrides.exclude || DEFAULT_EXCLUDE_PATTERNS,
-    fileTypeMapping: {
-      ...DEFAULT_FILE_TYPE_MAPPING,
-      ...overrides.fileTypeMapping
-    },
-    output: {
-      file: {
-        enabled: true,
-        path: "project-metadata.json",
-        ...overrides.output?.file
-      },
-      api: {
-        enabled: false,
-        endpoint: "",
-        ...overrides.output?.api
-      }
-    },
-    koreanKeywords: overrides.koreanKeywords,
-    mode: overrides.mode || "production",
-    verbose: overrides.verbose || false
-  };
-}
-function validateConfig(config) {
-  const errors = [];
-  if (!config.projectId) {
-    errors.push("projectId is required");
-  }
-  if (config.output.api?.enabled && !config.output.api.endpoint) {
-    errors.push("API endpoint is required when api output is enabled");
-  }
-  if (config.include.length === 0) {
-    errors.push("At least one include pattern is required");
-  }
-  return errors;
-}
-function globToRegex(pattern) {
-  const escaped = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*\*/g, "{{GLOBSTAR}}").replace(/\*/g, "[^/]*").replace(/{{GLOBSTAR}}/g, ".*").replace(/\{([^}]+)\}/g, (_, group) => {
-    const alternatives = group.split(",").map((s) => s.trim());
-    return `(${alternatives.join("|")})`;
-  });
-  return new RegExp(`^${escaped}$`);
-}
-var TypeScriptParser = class {
-  constructor() {
-    this.compilerOptions = {
-      target: ts3.ScriptTarget.ESNext,
-      module: ts3.ModuleKind.ESNext,
-      jsx: ts3.JsxEmit.React,
-      esModuleInterop: true,
-      allowSyntheticDefaultImports: true,
-      strict: false
-    };
-  }
-  /**
-   * 소스 코드를 AST로 파싱
-   */
-  parse(content, filePath) {
-    return ts3.createSourceFile(
-      filePath,
-      content,
-      this.compilerOptions.target,
-      true,
-      this.getScriptKind(filePath)
-    );
-  }
-  /**
-   * 파일 확장자에 따른 ScriptKind 결정
-   */
-  getScriptKind(filePath) {
-    const ext = filePath.toLowerCase();
-    if (ext.endsWith(".tsx")) return ts3.ScriptKind.TSX;
-    if (ext.endsWith(".ts")) return ts3.ScriptKind.TS;
-    if (ext.endsWith(".jsx")) return ts3.ScriptKind.JSX;
-    if (ext.endsWith(".js")) return ts3.ScriptKind.JS;
-    return ts3.ScriptKind.Unknown;
-  }
-  /**
-   * AST 노드 순회
-   */
-  traverse(node, visitor) {
-    const shouldContinue = visitor(node);
-    if (shouldContinue === false) return;
-    ts3.forEachChild(node, (child) => this.traverse(child, visitor));
-  }
-  /**
-   * 특정 조건을 만족하는 노드 수집
-   */
-  findNodes(sourceFile, predicate) {
-    const results = [];
-    this.traverse(sourceFile, (node) => {
-      if (predicate(node)) {
-        results.push(node);
-      }
-    });
-    return results;
-  }
-  /**
-   * 노드의 텍스트 추출
-   */
-  getNodeText(node, sourceFile) {
-    return node.getText(sourceFile);
-  }
-  /**
-   * JSDoc 코멘트 추출
-   */
-  getJSDocComment(node) {
-    const jsDocNodes = ts3.getJSDocCommentsAndTags(node);
-    if (jsDocNodes.length === 0) return void 0;
-    return jsDocNodes.filter(ts3.isJSDoc).map((doc) => doc.comment).filter(Boolean).join("\n");
-  }
-};
-new TypeScriptParser();
-var SQLParser = class {
-  /**
-   * SQL 파일 파싱
-   */
-  parse(content, relativePath) {
-    const tables = this.extractTables(content);
-    const tableName = tables[0]?.name || this.extractNameFromPath(relativePath);
-    return {
-      path: relativePath,
-      type: "table",
-      name: tableName,
-      imports: [],
-      exports: tables.map((t) => ({
-        name: t.name,
-        isDefault: false,
-        isTypeOnly: false,
-        kind: "variable"
-      })),
-      metadata: {
-        tableName,
-        columns: tables[0]?.columns || []
-      }
-    };
-  }
-  /**
-   * CREATE TABLE 문에서 테이블 정보 추출
-   */
-  extractTables(content) {
-    const tables = [];
-    const createTableRegex = /CREATE\s+TABLE\s+(?:IF\s+NOT\s+EXISTS\s+)?["']?(\w+)["']?\s*\(([\s\S]*?)\);/gi;
-    let match;
-    while ((match = createTableRegex.exec(content)) !== null) {
-      const tableName = match[1];
-      const columnsBlock = match[2];
-      const columns = this.parseColumns(columnsBlock);
-      tables.push({ name: tableName, columns });
-    }
-    const alterTableRegex = /ALTER\s+TABLE\s+["']?(\w+)["']?\s+ADD\s+(?:COLUMN\s+)?["']?(\w+)["']?\s+(\w+)/gi;
-    while ((match = alterTableRegex.exec(content)) !== null) {
-      const tableName = match[1];
-      const columnName = match[2];
-      const columnType = match[3];
-      let table = tables.find((t) => t.name === tableName);
-      if (!table) {
-        table = { name: tableName, columns: [] };
-        tables.push(table);
-      }
-      table.columns.push({
-        name: columnName,
-        type: columnType,
-        nullable: true,
-        isPrimaryKey: false,
-        isForeignKey: false
-      });
-    }
-    return tables;
-  }
-  /**
-   * 컬럼 정의 파싱
-   */
-  parseColumns(columnsBlock) {
-    const columns = [];
-    const lines = columnsBlock.split(",").map((line) => line.trim()).filter(
-      (line) => line && !line.toUpperCase().startsWith("CONSTRAINT") && !line.toUpperCase().startsWith("PRIMARY KEY") && !line.toUpperCase().startsWith("FOREIGN KEY") && !line.toUpperCase().startsWith("UNIQUE") && !line.toUpperCase().startsWith("CHECK")
-    );
-    for (const line of lines) {
-      const column = this.parseColumnDefinition(line);
-      if (column) {
-        columns.push(column);
-      }
-    }
-    return columns;
-  }
-  /**
-   * 단일 컬럼 정의 파싱
-   */
-  parseColumnDefinition(line) {
-    const match = line.match(/^["']?(\w+)["']?\s+(\w+(?:\([^)]+\))?)/i);
-    if (!match) return null;
-    const [, name, type] = match;
-    const upperLine = line.toUpperCase();
-    return {
-      name,
-      type: type.toUpperCase(),
-      nullable: !upperLine.includes("NOT NULL"),
-      isPrimaryKey: upperLine.includes("PRIMARY KEY"),
-      isForeignKey: upperLine.includes("REFERENCES"),
-      references: this.extractReference(line)
-    };
-  }
-  /**
-   * REFERENCES 절에서 참조 정보 추출
-   */
-  extractReference(line) {
-    const match = line.match(
-      /REFERENCES\s+["']?(\w+)["']?\s*\(["']?(\w+)["']?\)/i
-    );
-    if (!match) return void 0;
-    return {
-      table: match[1],
-      column: match[2]
-    };
-  }
-  /**
-   * 파일 경로에서 테이블 이름 추출
-   */
-  extractNameFromPath(filePath) {
-    const filename = path2.basename(filePath);
-    const match = filename.match(/create_(\w+)_table/i);
-    return match ? match[1] : filename.replace(".sql", "");
-  }
-};
-var ImportExtractor = class {
-  /**
-   * SourceFile에서 모든 import 정보 추출
-   */
-  extract(sourceFile) {
-    const imports = [];
-    ts3.forEachChild(sourceFile, (node) => {
-      if (ts3.isImportDeclaration(node)) {
-        const importInfo = this.parseImportDeclaration(node);
-        if (importInfo) {
-          imports.push(importInfo);
-        }
-      }
-    });
-    return imports;
-  }
-  /**
-   * ImportDeclaration 노드를 ImportInfo로 변환
-   */
-  parseImportDeclaration(node) {
-    const moduleSpecifier = node.moduleSpecifier;
-    if (!ts3.isStringLiteral(moduleSpecifier)) {
-      return null;
-    }
-    const source = moduleSpecifier.text;
-    const specifiers = [];
-    let isDefault = false;
-    const isTypeOnly = node.importClause?.isTypeOnly || false;
-    const importClause = node.importClause;
-    if (!importClause) {
-      return {
-        source,
-        specifiers: [],
-        isDefault: false,
-        isTypeOnly: false
-      };
-    }
-    if (importClause.name) {
-      specifiers.push(importClause.name.text);
-      isDefault = true;
-    }
-    const namedBindings = importClause.namedBindings;
-    if (namedBindings) {
-      if (ts3.isNamespaceImport(namedBindings)) {
-        specifiers.push(`* as ${namedBindings.name.text}`);
-      } else if (ts3.isNamedImports(namedBindings)) {
-        for (const element of namedBindings.elements) {
-          const name = element.name.text;
-          const propertyName = element.propertyName?.text;
-          if (propertyName) {
-            specifiers.push(`${propertyName} as ${name}`);
-          } else {
-            specifiers.push(name);
-          }
-        }
-      }
-    }
-    return {
-      source,
-      specifiers,
-      isDefault,
-      isTypeOnly
-    };
-  }
-};
-var ExportExtractor = class {
-  /**
-   * SourceFile에서 모든 export 정보 추출
-   */
-  extract(sourceFile) {
-    const exports$1 = [];
-    ts3.forEachChild(sourceFile, (node) => {
-      const exportInfos = this.extractFromNode(node, sourceFile);
-      exports$1.push(...exportInfos);
-    });
-    return exports$1;
-  }
-  /**
-   * 노드에서 export 정보 추출
-   */
-  extractFromNode(node, sourceFile) {
-    const results = [];
-    if (ts3.isFunctionDeclaration(node) && this.hasExportModifier(node)) {
-      results.push({
-        name: node.name?.text || "anonymous",
-        isDefault: this.hasDefaultModifier(node),
-        isTypeOnly: false,
-        kind: "function"
-      });
-    }
-    if (ts3.isClassDeclaration(node) && this.hasExportModifier(node)) {
-      results.push({
-        name: node.name?.text || "anonymous",
-        isDefault: this.hasDefaultModifier(node),
-        isTypeOnly: false,
-        kind: "class"
-      });
-    }
-    if (ts3.isVariableStatement(node) && this.hasExportModifier(node)) {
-      for (const declaration of node.declarationList.declarations) {
-        if (ts3.isIdentifier(declaration.name)) {
-          results.push({
-            name: declaration.name.text,
-            isDefault: false,
-            isTypeOnly: false,
-            kind: "variable"
-          });
-        }
-      }
-    }
-    if (ts3.isTypeAliasDeclaration(node) && this.hasExportModifier(node)) {
-      results.push({
-        name: node.name.text,
-        isDefault: false,
-        isTypeOnly: true,
-        kind: "type"
-      });
-    }
-    if (ts3.isInterfaceDeclaration(node) && this.hasExportModifier(node)) {
-      results.push({
-        name: node.name.text,
-        isDefault: false,
-        isTypeOnly: true,
-        kind: "interface"
-      });
-    }
-    if (ts3.isExportAssignment(node) && !node.isExportEquals) {
-      const name = this.getExportDefaultName(node, sourceFile);
-      results.push({
-        name,
-        isDefault: true,
-        isTypeOnly: false,
-        kind: "variable"
-      });
-    }
-    if (ts3.isExportDeclaration(node)) {
-      const exportClause = node.exportClause;
-      if (exportClause && ts3.isNamedExports(exportClause)) {
-        for (const element of exportClause.elements) {
-          results.push({
-            name: element.name.text,
-            isDefault: false,
-            isTypeOnly: node.isTypeOnly,
-            kind: "variable"
-          });
-        }
-      }
-    }
-    return results;
-  }
-  /**
-   * export 키워드가 있는지 확인
-   */
-  hasExportModifier(node) {
-    const modifiers = ts3.canHaveModifiers(node) ? ts3.getModifiers(node) : void 0;
-    return modifiers?.some((m) => m.kind === ts3.SyntaxKind.ExportKeyword) || false;
-  }
-  /**
-   * default 키워드가 있는지 확인
-   */
-  hasDefaultModifier(node) {
-    const modifiers = ts3.canHaveModifiers(node) ? ts3.getModifiers(node) : void 0;
-    return modifiers?.some((m) => m.kind === ts3.SyntaxKind.DefaultKeyword) || false;
-  }
-  /**
-   * export default의 이름 추출
-   */
-  getExportDefaultName(node, _sourceFile) {
-    const expr = node.expression;
-    if (ts3.isIdentifier(expr)) {
-      return expr.text;
-    }
-    if (ts3.isArrowFunction(expr) || ts3.isFunctionExpression(expr)) {
-      return "default";
-    }
-    if (ts3.isCallExpression(expr) && ts3.isIdentifier(expr.expression)) {
-      const firstArg = expr.arguments[0];
-      if (firstArg && ts3.isIdentifier(firstArg)) {
-        return firstArg.text;
-      }
-    }
-    return "default";
-  }
-};
-var PropsExtractor = class {
-  /**
-   * SourceFile에서 Props 정보 추출
-   */
-  extract(sourceFile) {
-    const props = [];
-    const propsType = this.findPropsType(sourceFile);
-    if (propsType) {
-      props.push(...this.extractFromTypeNode(propsType, sourceFile));
-    }
-    const componentFunction = this.findComponentFunction(sourceFile);
-    if (componentFunction) {
-      props.push(
-        ...this.extractFromFunctionParams(componentFunction, sourceFile)
-      );
-    }
-    return this.deduplicateProps(props);
-  }
-  /**
-   * Props 타입 정의 찾기
-   */
-  findPropsType(sourceFile) {
-    let propsType;
-    ts3.forEachChild(sourceFile, (node) => {
-      if (ts3.isInterfaceDeclaration(node) && node.name.text.endsWith("Props")) {
-        propsType = node;
-      }
-      if (ts3.isTypeAliasDeclaration(node) && node.name.text.endsWith("Props")) {
-        propsType = node.type;
-      }
-    });
-    return propsType;
-  }
-  /**
-   * 컴포넌트 함수 찾기
-   */
-  findComponentFunction(sourceFile) {
-    let component;
-    ts3.forEachChild(sourceFile, (node) => {
-      if (ts3.isFunctionDeclaration(node) && this.isExported(node)) {
-        component = node;
-      }
-      if (ts3.isVariableStatement(node) && this.isExported(node)) {
-        for (const decl of node.declarationList.declarations) {
-          if (decl.initializer && (ts3.isArrowFunction(decl.initializer) || ts3.isFunctionExpression(decl.initializer))) {
-            component = decl.initializer;
-          }
-        }
-      }
-    });
-    return component;
-  }
-  /**
-   * 타입 노드에서 Props 추출
-   */
-  extractFromTypeNode(typeNode, sourceFile) {
-    const props = [];
-    if (ts3.isInterfaceDeclaration(typeNode)) {
-      for (const member of typeNode.members) {
-        const propInfo = this.extractMemberProp(member, sourceFile);
-        if (propInfo) {
-          props.push(propInfo);
-        }
-      }
-      return props;
-    }
-    if (ts3.isTypeLiteralNode(typeNode)) {
-      for (const member of typeNode.members) {
-        const propInfo = this.extractMemberProp(member, sourceFile);
-        if (propInfo) {
-          props.push(propInfo);
-        }
-      }
-    }
-    if (ts3.isIntersectionTypeNode(typeNode)) {
-      for (const type of typeNode.types) {
-        props.push(...this.extractFromTypeNode(type, sourceFile));
-      }
-    }
-    return props;
-  }
-  /**
-   * 타입 멤버에서 PropInfo 추출
-   */
-  extractMemberProp(member, sourceFile) {
-    if (!ts3.isPropertySignature(member)) {
-      return null;
-    }
-    const name = member.name;
-    if (!ts3.isIdentifier(name) && !ts3.isStringLiteral(name)) {
-      return null;
-    }
-    const propName = ts3.isIdentifier(name) ? name.text : name.text;
-    const required = !member.questionToken;
-    const type = member.type ? member.type.getText(sourceFile) : "any";
-    return {
-      name: propName,
-      type,
-      required
-    };
-  }
-  /**
-   * 함수 매개변수에서 Props 추출
-   */
-  extractFromFunctionParams(func, sourceFile) {
-    const props = [];
-    const firstParam = func.parameters[0];
-    if (!firstParam) return props;
-    if (ts3.isObjectBindingPattern(firstParam.name)) {
-      for (const element of firstParam.name.elements) {
-        if (ts3.isBindingElement(element) && ts3.isIdentifier(element.name)) {
-          props.push({
-            name: element.name.text,
-            type: "unknown",
-            required: !element.initializer,
-            defaultValue: element.initializer?.getText(sourceFile)
-          });
-        }
-      }
-    }
-    return props;
-  }
-  /**
-   * export 키워드가 있는지 확인
-   */
-  isExported(node) {
-    const modifiers = ts3.canHaveModifiers(node) ? ts3.getModifiers(node) : void 0;
-    return modifiers?.some((m) => m.kind === ts3.SyntaxKind.ExportKeyword) || false;
-  }
-  /**
-   * 중복 Props 제거
-   */
-  deduplicateProps(props) {
-    const seen = /* @__PURE__ */ new Set();
-    return props.filter((prop) => {
-      if (seen.has(prop.name)) return false;
-      seen.add(prop.name);
-      return true;
-    });
-  }
-};
-
-// src/utils/naming-utils.ts
-function splitCamelCase(str) {
-  return str.replace(/([a-z])([A-Z])/g, "$1 $2").split(" ").filter(Boolean);
-}
-function splitPascalCase(str) {
-  return str.replace(/([A-Z])([A-Z][a-z])/g, "$1 $2").replace(/([a-z])([A-Z])/g, "$1 $2").split(" ").filter(Boolean);
-}
-function splitSnakeCase(str) {
-  return str.split("_").filter(Boolean);
-}
-function splitKebabCase(str) {
-  return str.split("-").filter(Boolean);
-}
-function splitIntoWords(str) {
-  const words = /* @__PURE__ */ new Set();
-  const parts = str.split(/[-_]/);
-  for (const part of parts) {
-    const camelSplit = splitCamelCase(part);
-    camelSplit.forEach((w) => words.add(w.toLowerCase()));
-  }
-  return [...words];
-}
-function extractAcronyms(str) {
-  const acronyms = [];
-  const matches = str.match(/[A-Z]{2,}/g);
-  if (matches) {
-    acronyms.push(...matches);
-  }
-  return acronyms;
-}
-function toAllCases(str) {
-  const words = splitIntoWords(str);
-  return {
-    camel: words.map(
-      (w, i) => i === 0 ? w.toLowerCase() : w.charAt(0).toUpperCase() + w.slice(1).toLowerCase()
-    ).join(""),
-    pascal: words.map((w) => w.charAt(0).toUpperCase() + w.slice(1).toLowerCase()).join(""),
-    snake: words.map((w) => w.toLowerCase()).join("_"),
-    kebab: words.map((w) => w.toLowerCase()).join("-")
-  };
-}
-
-// src/utils/korean-mapper.ts
-var KOREAN_KEYWORD_MAP = {
-  // 공통 동작
-  create: ["\uC0DD\uC131", "\uB9CC\uB4E4\uAE30", "\uCD94\uAC00"],
-  read: ["\uC77D\uAE30", "\uC870\uD68C"],
-  update: ["\uC218\uC815", "\uC5C5\uB370\uC774\uD2B8", "\uBCC0\uACBD"],
-  delete: ["\uC0AD\uC81C", "\uC81C\uAC70"],
-  list: ["\uBAA9\uB85D", "\uB9AC\uC2A4\uD2B8"],
-  search: ["\uAC80\uC0C9", "\uCC3E\uAE30"],
-  filter: ["\uD544\uD130", "\uD544\uD130\uB9C1"],
-  sort: ["\uC815\uB82C"],
-  submit: ["\uC81C\uCD9C", "\uC804\uC1A1"],
-  cancel: ["\uCDE8\uC18C"],
-  confirm: ["\uD655\uC778"],
-  save: ["\uC800\uC7A5"],
-  load: ["\uB85C\uB4DC", "\uBD88\uB7EC\uC624\uAE30"],
-  fetch: ["\uAC00\uC838\uC624\uAE30", "\uBD88\uB7EC\uC624\uAE30"],
-  // UI 요소
-  button: ["\uBC84\uD2BC"],
-  modal: ["\uBAA8\uB2EC", "\uD31D\uC5C5"],
-  dialog: ["\uB2E4\uC774\uC5BC\uB85C\uADF8", "\uB300\uD654\uC0C1\uC790"],
-  form: ["\uD3FC", "\uC591\uC2DD"],
-  input: ["\uC785\uB825", "\uC778\uD48B"],
-  select: ["\uC120\uD0DD", "\uC140\uB809\uD2B8", "\uB4DC\uB86D\uB2E4\uC6B4"],
-  checkbox: ["\uCCB4\uD06C\uBC15\uC2A4", "\uCCB4\uD06C"],
-  table: ["\uD14C\uC774\uBE14", "\uD45C"],
-  card: ["\uCE74\uB4DC"],
-  tab: ["\uD0ED"],
-  menu: ["\uBA54\uB274"],
-  header: ["\uD5E4\uB354", "\uBA38\uB9AC\uAE00"],
-  footer: ["\uD478\uD130", "\uBC14\uB2E5\uAE00"],
-  sidebar: ["\uC0AC\uC774\uB4DC\uBC14"],
-  navbar: ["\uB124\uBE44\uAC8C\uC774\uC158", "\uB124\uBE44\uBC14"],
-  // 인증/사용자
-  auth: ["\uC778\uC99D", "\uB85C\uADF8\uC778"],
-  login: ["\uB85C\uADF8\uC778"],
-  logout: ["\uB85C\uADF8\uC544\uC6C3"],
-  register: ["\uD68C\uC6D0\uAC00\uC785", "\uAC00\uC785"],
-  signup: ["\uD68C\uC6D0\uAC00\uC785", "\uAC00\uC785"],
-  user: ["\uC0AC\uC6A9\uC790", "\uC720\uC800", "\uD68C\uC6D0"],
-  profile: ["\uD504\uB85C\uD544"],
-  password: ["\uBE44\uBC00\uBC88\uD638", "\uC554\uD638"],
-  permission: ["\uAD8C\uD55C"],
-  // 비즈니스
-  attendance: ["\uCD9C\uC11D", "\uCD9C\uACB0"],
-  check: ["\uCCB4\uD06C", "\uD655\uC778"],
-  schedule: ["\uC2A4\uCF00\uC904", "\uC77C\uC815"],
-  calendar: ["\uCE98\uB9B0\uB354", "\uB2EC\uB825"],
-  notification: ["\uC54C\uB9BC", "\uD1B5\uC9C0"],
-  message: ["\uBA54\uC2DC\uC9C0", "\uC54C\uB9BC"],
-  setting: ["\uC124\uC815"],
-  settings: ["\uC124\uC815"],
-  payment: ["\uACB0\uC81C", "\uC9C0\uBD88"],
-  order: ["\uC8FC\uBB38"],
-  product: ["\uC0C1\uD488", "\uC81C\uD488"],
-  cart: ["\uC7A5\uBC14\uAD6C\uB2C8"],
-  checkout: ["\uACB0\uC81C", "\uCCB4\uD06C\uC544\uC6C3"],
-  invoice: ["\uC1A1\uC7A5", "\uCCAD\uAD6C\uC11C"],
-  report: ["\uB9AC\uD3EC\uD2B8", "\uBCF4\uACE0\uC11C"],
-  dashboard: ["\uB300\uC2DC\uBCF4\uB4DC"],
-  analytics: ["\uBD84\uC11D", "\uD1B5\uACC4"],
-  statistics: ["\uD1B5\uACC4"],
-  // 상태
-  status: ["\uC0C1\uD0DC"],
-  pending: ["\uB300\uAE30\uC911", "\uB300\uAE30"],
-  active: ["\uD65C\uC131", "\uD65C\uC131\uD654"],
-  inactive: ["\uBE44\uD65C\uC131", "\uBE44\uD65C\uC131\uD654"],
-  completed: ["\uC644\uB8CC"],
-  error: ["\uC5D0\uB7EC", "\uC624\uB958"],
-  success: ["\uC131\uACF5"],
-  loading: ["\uB85C\uB529", "\uB85C\uB4DC\uC911"],
-  // 기타
-  date: ["\uB0A0\uC9DC"],
-  time: ["\uC2DC\uAC04"],
-  image: ["\uC774\uBBF8\uC9C0", "\uC0AC\uC9C4"],
-  file: ["\uD30C\uC77C"],
-  upload: ["\uC5C5\uB85C\uB4DC", "\uC62C\uB9AC\uAE30"],
-  download: ["\uB2E4\uC6B4\uB85C\uB4DC", "\uB0B4\uB824\uBC1B\uAE30"],
-  export: ["\uB0B4\uBCF4\uB0B4\uAE30", "\uC775\uC2A4\uD3EC\uD2B8"],
-  import: ["\uAC00\uC838\uC624\uAE30", "\uC784\uD3EC\uD2B8"],
-  api: ["API", "\uC5D0\uC774\uD53C\uC544\uC774"],
-  service: ["\uC11C\uBE44\uC2A4"],
-  hook: ["\uD6C5"],
-  component: ["\uCEF4\uD3EC\uB10C\uD2B8"],
-  page: ["\uD398\uC774\uC9C0"],
-  route: ["\uB77C\uC6B0\uD2B8", "\uACBD\uB85C"]
-};
-function findKoreanKeywords(englishKeyword) {
-  const lower = englishKeyword.toLowerCase();
-  if (KOREAN_KEYWORD_MAP[lower]) {
-    return KOREAN_KEYWORD_MAP[lower];
-  }
-  const results = [];
-  for (const [key, values] of Object.entries(KOREAN_KEYWORD_MAP)) {
-    if (lower.includes(key) || key.includes(lower)) {
-      results.push(...values);
-    }
-  }
-  return [...new Set(results)];
-}
-function extendKoreanMap(customMap) {
-  return {
-    ...KOREAN_KEYWORD_MAP,
-    ...customMap
-  };
-}
-
-// src/core/extractors/keyword-extractor.ts
-var KeywordExtractor = class {
-  constructor(customKoreanMap) {
-    this.customKoreanMap = customKoreanMap || {};
-  }
-  /**
-   * 다양한 소스에서 키워드 추출
-   */
-  extract(name, path5, exports$1 = [], props = []) {
-    const keywords = /* @__PURE__ */ new Set();
-    this.extractFromName(name, keywords);
-    this.extractFromPath(path5, keywords);
-    for (const exportName of exports$1) {
-      this.extractFromName(exportName, keywords);
-    }
-    for (const propName of props) {
-      this.extractFromName(propName, keywords);
-    }
-    const allEnglishKeywords = [...keywords];
-    for (const keyword of allEnglishKeywords) {
-      const koreanKeywords = this.findKorean(keyword);
-      koreanKeywords.forEach((k) => keywords.add(k));
-    }
-    return [...keywords].filter((k) => k.length > 1);
-  }
-  /**
-   * 이름에서 키워드 추출
-   */
-  extractFromName(name, keywords) {
-    keywords.add(name.toLowerCase());
-    const camelParts = splitCamelCase(name);
-    camelParts.forEach((part) => keywords.add(part.toLowerCase()));
-    const pascalParts = splitPascalCase(name);
-    pascalParts.forEach((part) => keywords.add(part.toLowerCase()));
-    const snakeParts = splitSnakeCase(name);
-    snakeParts.forEach((part) => keywords.add(part.toLowerCase()));
-    const acronyms = extractAcronyms(name);
-    acronyms.forEach((acr) => keywords.add(acr.toLowerCase()));
-  }
-  /**
-   * 경로에서 키워드 추출
-   */
-  extractFromPath(path5, keywords) {
-    const excludeNames = /* @__PURE__ */ new Set([
-      "src",
-      "app",
-      "components",
-      "hooks",
-      "services",
-      "lib",
-      "utils",
-      "pages",
-      "api"
-    ]);
-    const segments = path5.replace(/\.[^/.]+$/, "").split("/").filter((s) => !excludeNames.has(s));
-    for (const segment of segments) {
-      this.extractFromName(segment, keywords);
-    }
-  }
-  /**
-   * 영어 키워드에 대응하는 한글 키워드 찾기
-   */
-  findKorean(englishKeyword) {
-    const customMatch = this.customKoreanMap[englishKeyword.toLowerCase()];
-    if (customMatch) {
-      return customMatch;
-    }
-    return findKoreanKeywords(englishKeyword);
-  }
-};
-var DependencyResolver = class {
-  constructor(aliasMap = {}, extensions = [".ts", ".tsx", ".js", ".jsx"]) {
-    this.aliasMap = new Map(Object.entries(aliasMap));
-    this.extensions = extensions;
-  }
-  /**
-   * import 경로를 실제 파일 경로로 해석
-   */
-  resolve(importSource, importerPath, rootDir) {
-    if (this.isExternalPackage(importSource)) {
-      return null;
-    }
-    const aliasResolved = this.resolveAlias(importSource);
-    let targetPath;
-    if (aliasResolved.startsWith("./") || aliasResolved.startsWith("../")) {
-      const importerDir = path2.dirname(path2.resolve(rootDir, importerPath));
-      targetPath = path2.resolve(importerDir, aliasResolved);
-    } else if (aliasResolved !== importSource) {
-      targetPath = path2.resolve(rootDir, aliasResolved);
-    } else {
-      return null;
-    }
-    const resolvedPath = this.resolveWithExtensions(targetPath);
-    if (resolvedPath) {
-      return path2.relative(rootDir, resolvedPath);
-    }
-    return null;
-  }
-  /**
-   * 외부 패키지인지 확인
-   */
-  isExternalPackage(source) {
-    if (source.startsWith("./") || source.startsWith("../")) {
-      return false;
-    }
-    for (const alias of this.aliasMap.keys()) {
-      if (source.startsWith(alias)) {
-        return false;
-      }
-    }
-    return true;
-  }
-  /**
-   * alias 해석
-   */
-  resolveAlias(source) {
-    for (const [alias, target] of this.aliasMap.entries()) {
-      if (source === alias) {
-        return target;
-      }
-      if (source.startsWith(alias + "/")) {
-        return source.replace(alias, target);
-      }
-    }
-    return source;
-  }
-  /**
-   * 확장자를 추가하여 파일 경로 해석
-   */
-  resolveWithExtensions(targetPath) {
-    if (fs.existsSync(targetPath)) {
-      try {
-        const stat = fs.statSync(targetPath);
-        if (stat.isFile()) {
-          return targetPath;
-        }
-        if (stat.isDirectory()) {
-          return this.findIndexFile(targetPath);
-        }
-      } catch {
-      }
-    }
-    for (const ext of this.extensions) {
-      const withExt = targetPath + ext;
-      if (fs.existsSync(withExt)) {
-        return withExt;
-      }
-    }
-    return this.findIndexFile(targetPath);
-  }
-  /**
-   * 디렉토리에서 index 파일 찾기
-   */
-  findIndexFile(dirPath) {
-    for (const ext of this.extensions) {
-      const indexPath = path2.join(dirPath, `index${ext}`);
-      if (fs.existsSync(indexPath)) {
-        return indexPath;
-      }
-    }
-    return null;
-  }
-};
-
-// src/core/resolvers/call-graph-builder.ts
-var CallGraphBuilder = class {
-  constructor(aliasMap) {
-    const defaultAliases = {
-      "@": "src",
-      "@/": "src/",
-      "~": "src",
-      "~/": "src/"
-    };
-    this.resolver = new DependencyResolver({
-      ...defaultAliases,
-      ...aliasMap
-    });
-  }
-  /**
-   * 파싱된 파일들로부터 호출 그래프 구축
-   */
-  build(parsedFiles, rootDir) {
-    const graph = /* @__PURE__ */ new Map();
-    const filePathSet = new Set(parsedFiles.map((f) => f.path));
-    for (const file of parsedFiles) {
-      const calls = this.resolveCalls(file, rootDir, filePathSet);
-      graph.set(file.path, {
-        calls,
-        calledBy: []
-      });
-    }
-    for (const [filePath, entry] of graph.entries()) {
-      for (const calledPath of entry.calls) {
-        const calledEntry = graph.get(calledPath);
-        if (calledEntry) {
-          calledEntry.calledBy.push(filePath);
-        }
-      }
-    }
-    return graph;
-  }
-  /**
-   * 파일이 호출하는 다른 파일들을 해석
-   */
-  resolveCalls(file, rootDir, validPaths) {
-    const calls = [];
-    for (const imp of file.imports) {
-      if (imp.isTypeOnly) continue;
-      const resolvedPath = this.resolver.resolve(
-        imp.source,
-        file.path,
-        rootDir
-      );
-      if (resolvedPath && validPaths.has(resolvedPath)) {
-        calls.push(resolvedPath);
-      }
-    }
-    return [...new Set(calls)];
-  }
-};
-function generateId(projectId, filePath) {
-  const input = `${projectId}:${filePath}`;
-  return crypto.createHash("sha256").update(input).digest("hex").slice(0, 16);
-}
-var ProjectAnalyzer = class {
-  constructor(config) {
-    this.config = config;
-    this.tsParser = new TypeScriptParser();
-    this.sqlParser = new SQLParser();
-    this.importExtractor = new ImportExtractor();
-    this.exportExtractor = new ExportExtractor();
-    this.propsExtractor = new PropsExtractor();
-    this.keywordExtractor = new KeywordExtractor(config.koreanKeywords);
-    this.callGraphBuilder = new CallGraphBuilder();
-  }
-  /**
-   * 프로젝트 분석 실행
-   */
-  async analyze(rootDir) {
-    const startTime = Date.now();
-    const parseErrors = [];
-    const files = await this.collectFiles(rootDir);
-    if (this.config.verbose) {
-      console.log(`[metadata-plugin] Found ${files.length} files to analyze`);
-    }
-    const parsedFiles = [];
-    for (const filePath of files) {
-      try {
-        const parsed = await this.parseFile(filePath, rootDir);
-        if (parsed) {
-          parsedFiles.push(parsed);
-        }
-      } catch (error) {
-        const errorMessage = error instanceof Error ? error.message : "Unknown error";
-        parseErrors.push(`${filePath}: ${errorMessage}`);
-      }
-    }
-    const callGraph = this.callGraphBuilder.build(parsedFiles, rootDir);
-    const items = parsedFiles.map(
-      (parsed) => this.createIndexItem(parsed, callGraph)
-    );
-    const stats = this.calculateStats(items, parseErrors);
-    if (this.config.verbose) {
-      console.log(
-        `[metadata-plugin] Analysis completed in ${Date.now() - startTime}ms`
-      );
-      console.log(`[metadata-plugin] Processed ${items.length} items`);
-    }
-    return {
-      items,
-      stats,
-      timestamp: (/* @__PURE__ */ new Date()).toISOString()
-    };
-  }
-  /**
-   * 대상 파일 수집
-   */
-  async collectFiles(rootDir) {
-    const allFiles = [];
-    for (const pattern of this.config.include) {
-      const matches = await glob(pattern, {
-        cwd: rootDir,
-        ignore: this.config.exclude,
-        absolute: true
-      });
-      allFiles.push(...matches);
-    }
-    return [...new Set(allFiles)];
-  }
-  /**
-   * 단일 파일 파싱
-   */
-  async parseFile(filePath, rootDir) {
-    const relativePath = path2.relative(rootDir, filePath);
-    const fileType = this.determineFileType(relativePath);
-    if (!fileType) {
-      return null;
-    }
-    const content = await fs3.readFile(filePath, "utf-8");
-    const ext = path2.extname(filePath);
-    if (ext === ".sql") {
-      return this.sqlParser.parse(content, relativePath);
-    }
-    const sourceFile = this.tsParser.parse(content, filePath);
-    const imports = this.importExtractor.extract(sourceFile);
-    const exports$1 = this.exportExtractor.extract(sourceFile);
-    const props = fileType === "component" ? this.propsExtractor.extract(sourceFile) : void 0;
-    return {
-      path: relativePath,
-      type: fileType,
-      name: this.extractName(relativePath, exports$1),
-      imports,
-      exports: exports$1,
-      props
-    };
-  }
-  /**
-   * 파일 타입 결정
-   */
-  determineFileType(relativePath) {
-    const sortedPatterns = Object.entries(this.config.fileTypeMapping).sort(
-      ([a], [b]) => b.length - a.length
-    );
-    for (const [pattern, type] of sortedPatterns) {
-      const regex = globToRegex(pattern);
-      if (regex.test(relativePath)) {
-        return type;
-      }
-    }
-    return null;
-  }
-  /**
-   * 파일/컴포넌트 이름 추출
-   */
-  extractName(relativePath, exports$1) {
-    const defaultExport = exports$1.find((e) => e.isDefault);
-    if (defaultExport && defaultExport.name !== "default") {
-      return defaultExport.name;
-    }
-    const basename3 = path2.basename(relativePath, path2.extname(relativePath));
-    if (["index", "page", "layout", "route"].includes(basename3)) {
-      const dirname4 = path2.dirname(relativePath);
-      const parentName = path2.basename(dirname4);
-      return parentName !== "." ? parentName : basename3;
-    }
-    return basename3;
-  }
-  /**
-   * CodeIndexItem 생성
-   */
-  createIndexItem(parsed, callGraph) {
-    const graphEntry = callGraph.get(parsed.path) || {
-      calls: [],
-      calledBy: []
-    };
-    const keywords = this.keywordExtractor.extract(
-      parsed.name,
-      parsed.path,
-      parsed.exports.map((e) => e.name),
-      parsed.props?.map((p) => p.name)
-    );
-    const searchText = this.buildSearchText(parsed, keywords);
-    return {
-      id: generateId(this.config.projectId, parsed.path),
-      projectId: this.config.projectId,
-      type: parsed.type,
-      name: parsed.name,
-      path: parsed.path,
-      keywords,
-      searchText,
-      calls: graphEntry.calls,
-      calledBy: graphEntry.calledBy,
-      metadata: {
-        exports: parsed.exports.map((e) => e.name),
-        props: parsed.props?.map((p) => p.name),
-        ...parsed.metadata
-      }
-    };
-  }
-  /**
-   * 검색용 텍스트 생성
-   */
-  buildSearchText(parsed, keywords) {
-    const parts = [
-      parsed.name,
-      parsed.path,
-      ...keywords,
-      ...parsed.exports.map((e) => e.name),
-      ...parsed.props?.map((p) => p.name) || []
-    ];
-    return parts.join(" ").toLowerCase();
-  }
-  /**
-   * 분석 통계 계산
-   */
-  calculateStats(items, parseErrors) {
-    const byType = {
-      route: 0,
-      component: 0,
-      hook: 0,
-      service: 0,
-      api: 0,
-      table: 0,
-      utility: 0
-    };
-    for (const item of items) {
-      byType[item.type]++;
-    }
-    return {
-      totalFiles: items.length,
-      byType,
-      parseErrors
-    };
-  }
-};
-var FileWriter = class {
-  constructor(config) {
-    this.config = config;
-  }
-  /**
-   * 분석 결과를 파일로 저장
-   */
-  async write(result, outputPath) {
-    const dir = path2.dirname(outputPath);
-    await fs3.mkdir(dir, { recursive: true });
-    const output = this.formatOutput(result);
-    await fs3.writeFile(outputPath, output, "utf-8");
-  }
-  /**
-   * 출력 형식 생성
-   */
-  formatOutput(result) {
-    const output = {
-      version: "1.0.0",
-      projectId: this.config.projectId,
-      generatedAt: result.timestamp,
-      stats: result.stats,
-      items: result.items
-    };
-    if (this.config.mode === "production") {
-      return JSON.stringify(output);
-    }
-    return JSON.stringify(output, null, 2);
-  }
-};
-
-// src/core/output/api-sender.ts
-var ApiSender = class {
-  constructor(config, options = {}) {
-    this.config = config;
-    this.maxRetries = options.maxRetries ?? 3;
-    this.retryDelay = options.retryDelay ?? 1e3;
-  }
-  /**
-   * 분석 결과를 API로 전송
-   */
-  async send(result) {
-    const apiConfig = this.config.output.api;
-    if (!apiConfig?.enabled || !apiConfig.endpoint) {
-      return;
-    }
-    const payload = {
-      projectId: this.config.projectId,
-      timestamp: result.timestamp,
-      items: result.items,
-      stats: result.stats
-    };
-    let lastError = null;
-    for (let attempt = 0; attempt < this.maxRetries; attempt++) {
-      try {
-        await this.sendRequest(
-          apiConfig.endpoint,
-          payload,
-          apiConfig.headers
-        );
-        return;
-      } catch (error) {
-        lastError = error instanceof Error ? error : new Error(String(error));
-        if (this.config.verbose) {
-          console.warn(
-            `[metadata-plugin] API send attempt ${attempt + 1} failed:`,
-            lastError.message
-          );
-        }
-        if (attempt < this.maxRetries - 1) {
-          await this.delay(this.retryDelay * (attempt + 1));
-        }
-      }
-    }
-    throw new Error(
-      `Failed to send metadata after ${this.maxRetries} attempts: ${lastError?.message}`
-    );
-  }
-  /**
-   * HTTP POST 요청
-   */
-  async sendRequest(endpoint, payload, headers) {
-    const response = await fetch(endpoint, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        ...headers
-      },
-      body: JSON.stringify(payload)
-    });
-    if (!response.ok) {
-      const errorText = await response.text();
-      throw new Error(`API request failed: ${response.status} ${errorText}`);
-    }
-  }
-  /**
-   * 지연 함수
-   */
-  delay(ms) {
-    return new Promise((resolve2) => setTimeout(resolve2, ms));
-  }
-};
-var SupabaseApiSender = class extends ApiSender {
-  /**
-   * Supabase upsert 형식으로 전송
-   */
-  async send(result) {
-    const apiConfig = this.config.output.api;
-    if (!apiConfig?.enabled || !apiConfig.endpoint) {
-      return;
-    }
-    const records = result.items.map((item) => ({
-      id: item.id,
-      project_id: item.projectId,
-      type: item.type,
-      name: item.name,
-      path: item.path,
-      keywords: item.keywords,
-      search_text: item.searchText,
-      calls: item.calls,
-      called_by: item.calledBy,
-      metadata: item.metadata,
-      updated_at: result.timestamp
-    }));
-    const batchSize = 500;
-    for (let i = 0; i < records.length; i += batchSize) {
-      const batch = records.slice(i, i + batchSize);
-      const response = await fetch(apiConfig.endpoint, {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json",
-          Prefer: "resolution=merge-duplicates",
-          ...apiConfig.headers
-        },
-        body: JSON.stringify(batch)
-      });
-      if (!response.ok) {
-        throw new Error(`Supabase upsert failed: ${response.status}`);
-      }
-    }
-  }
-};
-
-export { ApiSender, CallGraphBuilder, DEFAULT_EXCLUDE_PATTERNS, DEFAULT_FILE_TYPE_MAPPING, DEFAULT_INCLUDE_PATTERNS, DependencyResolver, ExportExtractor, FileWriter, ImportExtractor, KOREAN_KEYWORD_MAP, KeywordExtractor, ProjectAnalyzer, PropsExtractor, SQLParser, SupabaseApiSender, TypeScriptParser, createDefaultConfig, extendKoreanMap, extractAcronyms, findKoreanKeywords, generateId, splitCamelCase, splitIntoWords, splitKebabCase, splitPascalCase, splitSnakeCase, toAllCases, validateConfig };
-//# sourceMappingURL=chunk-ECKCIPM5.js.map
-//# sourceMappingURL=chunk-ECKCIPM5.js.map