metadatafy 1.0.1 → 1.0.3

package/dist/cli.js

@@ -1,1255 +1,5 @@
 #!/usr/bin/env node
-import { parseArgs } from 'util';
-import * as path2 from 'path';
-import * as fs4 from 'fs/promises';
-import { glob } from 'glob';
-import ts3 from 'typescript';
-import * as fs from 'fs';
-import * as crypto from 'crypto';
-
-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 extractAcronyms(str) {
-  const acronyms = [];
-  const matches = str.match(/[A-Z]{2,}/g);
-  if (matches) {
-    acronyms.push(...matches);
-  }
-  return acronyms;
-}
-
-// 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)];
-}
-
-// src/core/extractors/keyword-extractor.ts
-var KeywordExtractor = class {
-  constructor(customKoreanMap) {
-    this.customKoreanMap = customKoreanMap || {};
-  }
-  /**
-   * 다양한 소스에서 키워드 추출
-   */
-  extract(name, path6, exports$1 = [], props = []) {
-    const keywords = /* @__PURE__ */ new Set();
-    this.extractFromName(name, keywords);
-    this.extractFromPath(path6, 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(path6, keywords) {
-    const excludeNames = /* @__PURE__ */ new Set([
-      "src",
-      "app",
-      "components",
-      "hooks",
-      "services",
-      "lib",
-      "utils",
-      "pages",
-      "api"
-    ]);
-    const segments = path6.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)];
-  }
-};
-
-// 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 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}$`);
-}
-function generateId(projectId, filePath) {
-  const input = `${projectId}:${filePath}`;
-  return crypto.createHash("sha256").update(input).digest("hex").slice(0, 16);
-}
-
-// src/core/analyzer.ts
-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 fs4.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 basename4 = path2.basename(relativePath, path2.extname(relativePath));
-    if (["index", "page", "layout", "route"].includes(basename4)) {
-      const dirname4 = path2.dirname(relativePath);
-      const parentName = path2.basename(dirname4);
-      return parentName !== "." ? parentName : basename4;
-    }
-    return basename4;
-  }
-  /**
-   * 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 fs4.mkdir(dir, { recursive: true });
-    const output = this.formatOutput(result);
-    await fs4.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((resolve3) => setTimeout(resolve3, ms));
-  }
-};
-
-// src/cli.ts
-var VERSION = "1.0.1";
-var HELP_TEXT = `
+import {d,y,z,A as A$1}from'./chunk-WUEHYY36.js';import {parseArgs}from'util';import*as a from'path';import*as r from'fs/promises';var v="1.0.1",b=`
 metadatafy - \uD504\uB85C\uC81D\uD2B8 \uBA54\uD0C0\uB370\uC774\uD130 \uCD94\uCD9C \uB3C4\uAD6C
 
 Usage:
@@ -1267,8 +17,7 @@ Examples:
   metadatafy analyze
   metadatafy analyze --project-id my-project --output ./metadata.json
   metadatafy init
-`;
-var ANALYZE_HELP = `
+`,P=`
 Usage: metadatafy analyze [options]
 
 Options:
@@ -1277,174 +26,9 @@ Options:
   -c, --config <path>     \uC124\uC815 \uD30C\uC77C \uACBD\uB85C
   --verbose               \uC0C1\uC138 \uB85C\uADF8 \uCD9C\uB825
   -h, --help              \uB3C4\uC6C0\uB9D0 \uD45C\uC2DC
-`;
-async function main() {
-  const args = process.argv.slice(2);
-  if (args.length === 0 || args[0] === "-h" || args[0] === "--help") {
-    console.log(HELP_TEXT);
-    process.exit(0);
-  }
-  if (args[0] === "-v" || args[0] === "--version") {
-    console.log(VERSION);
-    process.exit(0);
-  }
-  const command = args[0];
-  switch (command) {
-    case "analyze":
-      await runAnalyze(args.slice(1));
-      break;
-    case "init":
-      await runInit();
-      break;
-    default:
-      console.error(`Unknown command: ${command}`);
-      console.log(HELP_TEXT);
-      process.exit(1);
-  }
-}
-async function runAnalyze(args) {
-  const { values } = parseArgs({
-    args,
-    options: {
-      "project-id": { type: "string", short: "p" },
-      output: { type: "string", short: "o" },
-      config: { type: "string", short: "c" },
-      verbose: { type: "boolean" },
-      help: { type: "boolean", short: "h" }
-    }
-  });
-  if (values.help) {
-    console.log(ANALYZE_HELP);
-    process.exit(0);
-  }
-  const rootDir = process.cwd();
-  const projectId = values["project-id"] || path2.basename(rootDir);
-  const outputPath = values.output || "project-metadata.json";
-  const verbose = values.verbose || false;
-  let configFromFile = {};
-  if (values.config) {
-    try {
-      const configContent = await fs4.readFile(values.config, "utf-8");
-      configFromFile = JSON.parse(configContent);
-    } catch (error) {
-      console.error(`Failed to load config file: ${values.config}`);
-      process.exit(1);
-    }
-  } else {
-    const defaultConfigPath = path2.join(rootDir, "metadata.config.json");
-    try {
-      const configContent = await fs4.readFile(defaultConfigPath, "utf-8");
-      configFromFile = JSON.parse(configContent);
-      if (verbose) {
-        console.log(`Loaded config from ${defaultConfigPath}`);
-      }
-    } catch {
-    }
-  }
-  const config = createDefaultConfig({
-    ...configFromFile,
-    projectId,
-    verbose,
-    output: {
-      file: {
-        enabled: true,
-        path: outputPath
-      },
-      ...configFromFile.output
-    }
-  });
-  console.log(`
-\u{1F4E6} Analyzing project: ${projectId}`);
-  console.log(`\u{1F4C1} Root directory: ${rootDir}
-`);
-  const analyzer = new ProjectAnalyzer(config);
-  const fileWriter = new FileWriter(config);
-  try {
-    const startTime = Date.now();
-    const result = await analyzer.analyze(rootDir);
-    const duration = Date.now() - startTime;
-    const fullOutputPath = path2.resolve(rootDir, outputPath);
-    await fileWriter.write(result, fullOutputPath);
-    if (config.output.api?.enabled && config.output.api.endpoint) {
-      const apiSender = new ApiSender(config);
-      await apiSender.send(result);
-      console.log(`\u2601\uFE0F  Sent to API: ${config.output.api.endpoint}`);
-    }
-    console.log(`\u2705 Analysis completed in ${duration}ms
-`);
-    console.log(`\u{1F4CA} Results:`);
-    console.log(`   Total files: ${result.stats.totalFiles}`);
-    console.log(`   - Routes: ${result.stats.byType.route}`);
-    console.log(`   - Components: ${result.stats.byType.component}`);
-    console.log(`   - Hooks: ${result.stats.byType.hook}`);
-    console.log(`   - Services: ${result.stats.byType.service}`);
-    console.log(`   - APIs: ${result.stats.byType.api}`);
-    console.log(`   - Tables: ${result.stats.byType.table}`);
-    console.log(`   - Utilities: ${result.stats.byType.utility}`);
-    console.log(`
-\u{1F4C4} Output: ${fullOutputPath}`);
-    if (result.stats.parseErrors.length > 0) {
-      console.log(`
-\u26A0\uFE0F  Parse errors (${result.stats.parseErrors.length}):`);
-      result.stats.parseErrors.slice(0, 5).forEach((err) => {
-        console.log(`   - ${err}`);
-      });
-      if (result.stats.parseErrors.length > 5) {
-        console.log(`   ... and ${result.stats.parseErrors.length - 5} more`);
-      }
-    }
-    console.log("");
-  } catch (error) {
-    console.error("\u274C Analysis failed:", error);
-    process.exit(1);
-  }
-}
-async function runInit() {
-  const rootDir = process.cwd();
-  const configPath = path2.join(rootDir, "metadata.config.json");
-  try {
-    await fs4.access(configPath);
-    console.log(`\u26A0\uFE0F  Config file already exists: ${configPath}`);
-    process.exit(1);
-  } catch {
-  }
-  const defaultConfig = {
-    projectId: path2.basename(rootDir),
-    include: [
-      "app/**/*.{ts,tsx}",
-      "pages/**/*.{ts,tsx}",
-      "components/**/*.{ts,tsx}",
-      "hooks/**/*.{ts,tsx}",
-      "services/**/*.ts",
-      "lib/**/*.ts",
-      "src/**/*.{ts,tsx}"
-    ],
-    exclude: [
-      "**/node_modules/**",
-      "**/.next/**",
-      "**/dist/**",
-      "**/*.test.{ts,tsx}",
-      "**/*.spec.{ts,tsx}"
-    ],
-    output: {
-      file: {
-        enabled: true,
-        path: "project-metadata.json"
-      },
-      api: {
-        enabled: false,
-        endpoint: ""
-      }
-    },
-    koreanKeywords: {},
-    verbose: false
-  };
-  await fs4.writeFile(configPath, JSON.stringify(defaultConfig, null, 2));
-  console.log(`\u2705 Created config file: ${configPath}`);
-}
-main().catch((error) => {
-  console.error("Fatal error:", error);
-  process.exit(1);
-});
-//# sourceMappingURL=cli.js.map
-//# sourceMappingURL=cli.js.map
+`;async function E(){let e=process.argv.slice(2);(e.length===0||e[0]==="-h"||e[0]==="--help")&&(console.log(b),process.exit(0)),(e[0]==="-v"||e[0]==="--version")&&(console.log(v),process.exit(0));let t=e[0];switch(t){case "analyze":await T(e.slice(1));break;case "init":await A();break;default:console.error(`Unknown command: ${t}`),console.log(b),process.exit(1);}}async function T(e){let{values:t}=parseArgs({args:e,options:{"project-id":{type:"string",short:"p"},output:{type:"string",short:"o"},config:{type:"string",short:"c"},verbose:{type:"boolean"},help:{type:"boolean",short:"h"}}});t.help&&(console.log(P),process.exit(0));let n=process.cwd(),l=t["project-id"]||a.basename(n),p=t.output||"project-metadata.json",f=t.verbose||false,c={};if(t.config)try{let s=await r.readFile(t.config,"utf-8");c=JSON.parse(s);}catch{console.error(`Failed to load config file: ${t.config}`),process.exit(1);}else {let s=a.join(n,"metadata.config.json");try{let o=await r.readFile(s,"utf-8");c=JSON.parse(o),f&&console.log(`Loaded config from ${s}`);}catch{}}let i=d({...c,projectId:l,verbose:f,output:{file:{enabled:true,path:p},...c.output}});console.log(`
+\u{1F4E6} Analyzing project: ${l}`),console.log(`\u{1F4C1} Root directory: ${n}
+`);let w=new y(i),$=new z(i);try{let s=Date.now(),o=await w.analyze(n),j=Date.now()-s,g=a.resolve(n,p);await $.write(o,g),i.output.api?.enabled&&i.output.api.endpoint&&(await new A$1(i).send(o),console.log(`\u2601\uFE0F  Sent to API: ${i.output.api.endpoint}`)),console.log(`\u2705 Analysis completed in ${j}ms
+`),console.log("\u{1F4CA} Results:"),console.log(`   Total files: ${o.stats.totalFiles}`),console.log(`   - Routes: ${o.stats.byType.route}`),console.log(`   - Components: ${o.stats.byType.component}`),console.log(`   - Hooks: ${o.stats.byType.hook}`),console.log(`   - Services: ${o.stats.byType.service}`),console.log(`   - APIs: ${o.stats.byType.api}`),console.log(`   - Tables: ${o.stats.byType.table}`),console.log(`   - Utilities: ${o.stats.byType.utility}`),console.log(`
+\u{1F4C4} Output: ${g}`),o.stats.parseErrors.length>0&&(console.log(`
+\u26A0\uFE0F  Parse errors (${o.stats.parseErrors.length}):`),o.stats.parseErrors.slice(0,5).forEach(d=>{console.log(`   - ${d}`);}),o.stats.parseErrors.length>5&&console.log(`   ... and ${o.stats.parseErrors.length-5} more`)),console.log("");}catch(s){console.error("\u274C Analysis failed:",s),process.exit(1);}}async function A(){let e=process.cwd(),t=a.join(e,"metadata.config.json");try{await r.access(t),console.log(`\u26A0\uFE0F  Config file already exists: ${t}`),process.exit(1);}catch{}let n={projectId:a.basename(e),include:["app/**/*.{ts,tsx}","pages/**/*.{ts,tsx}","components/**/*.{ts,tsx}","hooks/**/*.{ts,tsx}","services/**/*.ts","lib/**/*.ts","src/**/*.{ts,tsx}"],exclude:["**/node_modules/**","**/.next/**","**/dist/**","**/*.test.{ts,tsx}","**/*.spec.{ts,tsx}"],output:{file:{enabled:true,path:"project-metadata.json"},api:{enabled:false,endpoint:""}},koreanKeywords:{},verbose:false};await r.writeFile(t,JSON.stringify(n,null,2)),console.log(`\u2705 Created config file: ${t}`);}E().catch(e=>{console.error("Fatal error:",e),process.exit(1);});