@mandujs/core 0.3.3 → 0.3.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mandujs/core",
-  "version": "0.3.3",
+  "version": "0.3.4",
   "description": "Mandu Framework Core - Spec, Generator, Guard, Runtime",
   "type": "module",
   "main": "./src/index.ts",

package/src/index.ts

@@ -6,3 +6,4 @@ export * from "./report";
 export * from "./filling";
 export * from "./change";
 export * from "./error";
+export * from "./slot";

package/src/slot/corrector.ts

@@ -0,0 +1,282 @@
+/**
+ * Slot Content Corrector
+ * 슬롯 파일의 자동 수정 가능한 문제를 해결합니다.
+ */
+
+import type { SlotValidationIssue } from "./validator";
+
+export interface CorrectionResult {
+  corrected: boolean;
+  content: string;
+  appliedFixes: AppliedFix[];
+  remainingIssues: SlotValidationIssue[];
+}
+
+export interface AppliedFix {
+  code: string;
+  description: string;
+  before?: string;
+  after?: string;
+}
+
+// 금지된 import를 대체할 안전한 패턴
+const SAFE_ALTERNATIVES: Record<string, string> = {
+  fs: "// Use Bun.file() or Bun.write() instead of fs",
+  "node:fs": "// Use Bun.file() or Bun.write() instead of fs",
+  child_process: "// Use Bun.spawn() or Bun.spawnSync() instead",
+  "node:child_process": "// Use Bun.spawn() or Bun.spawnSync() instead",
+  cluster: "// Clustering should be handled at the infrastructure level",
+  "node:cluster": "// Clustering should be handled at the infrastructure level",
+  worker_threads: "// Use Bun workers or external job queues",
+  "node:worker_threads": "// Use Bun workers or external job queues",
+};
+
+/**
+ * 슬롯 내용을 자동 수정합니다.
+ */
+export function correctSlotContent(
+  content: string,
+  issues: SlotValidationIssue[]
+): CorrectionResult {
+  let correctedContent = content;
+  const appliedFixes: AppliedFix[] = [];
+  const remainingIssues: SlotValidationIssue[] = [];
+
+  for (const issue of issues) {
+    if (!issue.autoFixable) {
+      remainingIssues.push(issue);
+      continue;
+    }
+
+    const result = applyFix(correctedContent, issue);
+    if (result.fixed) {
+      correctedContent = result.content;
+      appliedFixes.push({
+        code: issue.code,
+        description: issue.message,
+        before: result.before,
+        after: result.after,
+      });
+    } else {
+      remainingIssues.push(issue);
+    }
+  }
+
+  return {
+    corrected: appliedFixes.length > 0,
+    content: correctedContent,
+    appliedFixes,
+    remainingIssues,
+  };
+}
+
+interface FixResult {
+  fixed: boolean;
+  content: string;
+  before?: string;
+  after?: string;
+}
+
+function applyFix(content: string, issue: SlotValidationIssue): FixResult {
+  switch (issue.code) {
+    case "FORBIDDEN_IMPORT":
+      return fixForbiddenImport(content, issue);
+
+    case "MISSING_MANDU_IMPORT":
+      return fixMissingManduImport(content);
+
+    case "MISSING_DEFAULT_EXPORT":
+      return fixMissingDefaultExport(content);
+
+    default:
+      return { fixed: false, content };
+  }
+}
+
+/**
+ * 금지된 import를 제거하고 주석으로 대체
+ */
+function fixForbiddenImport(
+  content: string,
+  issue: SlotValidationIssue
+): FixResult {
+  const lines = content.split("\n");
+
+  if (!issue.line) {
+    return { fixed: false, content };
+  }
+
+  const lineIndex = issue.line - 1;
+  const originalLine = lines[lineIndex];
+
+  // 어떤 금지된 모듈인지 찾기
+  let forbiddenModule = "";
+  for (const [module, alternative] of Object.entries(SAFE_ALTERNATIVES)) {
+    if (originalLine.includes(`'${module}'`) || originalLine.includes(`"${module}"`)) {
+      forbiddenModule = module;
+      break;
+    }
+  }
+
+  if (!forbiddenModule) {
+    return { fixed: false, content };
+  }
+
+  // import 문을 주석으로 대체
+  const alternative = SAFE_ALTERNATIVES[forbiddenModule];
+  lines[lineIndex] = `// REMOVED: ${originalLine.trim()}\n${alternative}`;
+
+  return {
+    fixed: true,
+    content: lines.join("\n"),
+    before: originalLine,
+    after: lines[lineIndex],
+  };
+}
+
+/**
+ * Mandu import 추가
+ */
+function fixMissingManduImport(content: string): FixResult {
+  const manduImport = `import { Mandu } from "@mandujs/core";\n`;
+
+  // 이미 다른 import가 있는지 확인
+  const hasImports = /^import\s+/m.test(content);
+
+  let newContent: string;
+  if (hasImports) {
+    // 첫 번째 import 앞에 추가
+    newContent = content.replace(/^(import\s+)/m, `${manduImport}$1`);
+  } else {
+    // 파일 맨 앞에 추가
+    newContent = manduImport + content;
+  }
+
+  return {
+    fixed: true,
+    content: newContent,
+    before: "(없음)",
+    after: manduImport.trim(),
+  };
+}
+
+/**
+ * default export 추가
+ */
+function fixMissingDefaultExport(content: string): FixResult {
+  // Mandu.filling()이 있는지 확인
+  const fillingMatch = content.match(/Mandu\s*\.\s*filling\s*\(\s*\)/);
+
+  if (!fillingMatch) {
+    // filling 패턴이 없으면 수정 불가
+    return { fixed: false, content };
+  }
+
+  // export default가 없는 Mandu.filling() 찾기
+  // 예: const handler = Mandu.filling()... -> export default Mandu.filling()...
+  const patterns = [
+    // const/let/var handler = Mandu.filling()
+    /^(\s*)(const|let|var)\s+\w+\s*=\s*(Mandu\s*\.\s*filling\s*\(\s*\))/m,
+    // 단독 Mandu.filling()
+    /^(\s*)(Mandu\s*\.\s*filling\s*\(\s*\))/m,
+  ];
+
+  for (const pattern of patterns) {
+    if (pattern.test(content)) {
+      const newContent = content.replace(pattern, "$1export default $3");
+      return {
+        fixed: true,
+        content: newContent,
+        before: content.match(pattern)?.[0],
+        after: newContent.match(/export default Mandu\.filling\(\)/)?.[0],
+      };
+    }
+  }
+
+  // 파일 끝에 export default 추가 시도
+  if (content.includes("Mandu.filling()") && !content.includes("export default")) {
+    // 마지막 세미콜론 또는 중괄호 뒤에 추가
+    const lastLine = content.trimEnd();
+    if (!lastLine.endsWith(";") && !lastLine.endsWith("}")) {
+      return { fixed: false, content };
+    }
+  }
+
+  return { fixed: false, content };
+}
+
+/**
+ * 여러 번의 수정 시도 (Self-correction loop)
+ */
+export async function runSlotCorrection(
+  content: string,
+  validateFn: (content: string) => { valid: boolean; issues: SlotValidationIssue[] },
+  maxRetries: number = 3
+): Promise<{
+  success: boolean;
+  finalContent: string;
+  attempts: number;
+  allFixes: AppliedFix[];
+  remainingIssues: SlotValidationIssue[];
+}> {
+  let currentContent = content;
+  let attempts = 0;
+  const allFixes: AppliedFix[] = [];
+
+  while (attempts < maxRetries) {
+    attempts++;
+
+    // 1. 검증
+    const validation = validateFn(currentContent);
+
+    if (validation.valid) {
+      return {
+        success: true,
+        finalContent: currentContent,
+        attempts,
+        allFixes,
+        remainingIssues: [],
+      };
+    }
+
+    // 2. 자동 수정 가능한 문제가 있는지 확인
+    const autoFixable = validation.issues.filter((i) => i.autoFixable);
+    if (autoFixable.length === 0) {
+      // 자동 수정 불가능한 문제만 남음
+      return {
+        success: false,
+        finalContent: currentContent,
+        attempts,
+        allFixes,
+        remainingIssues: validation.issues,
+      };
+    }
+
+    // 3. 수정 적용
+    const correction = correctSlotContent(currentContent, validation.issues);
+    allFixes.push(...correction.appliedFixes);
+
+    if (!correction.corrected) {
+      // 수정이 적용되지 않음
+      return {
+        success: false,
+        finalContent: currentContent,
+        attempts,
+        allFixes,
+        remainingIssues: validation.issues,
+      };
+    }
+
+    currentContent = correction.content;
+  }
+
+  // maxRetries 도달
+  const finalValidation = validateFn(currentContent);
+  return {
+    success: finalValidation.valid,
+    finalContent: currentContent,
+    attempts,
+    allFixes,
+    remainingIssues: finalValidation.issues,
+  };
+}

package/src/slot/index.ts

@@ -0,0 +1,18 @@
+/**
+ * Slot Module
+ * 슬롯 파일 검증 및 자동 수정 기능
+ */
+
+export {
+  validateSlotContent,
+  summarizeValidationIssues,
+  type SlotValidationIssue,
+  type SlotValidationResult,
+} from "./validator";
+
+export {
+  correctSlotContent,
+  runSlotCorrection,
+  type CorrectionResult,
+  type AppliedFix,
+} from "./corrector";

package/src/slot/validator.ts

@@ -0,0 +1,241 @@
+/**
+ * Slot Content Validator
+ * 슬롯 파일 내용을 작성 전에 검증하고 문제를 식별합니다.
+ */
+
+export interface SlotValidationIssue {
+  code: string;
+  severity: "error" | "warning";
+  message: string;
+  line?: number;
+  suggestion: string;
+  autoFixable: boolean;
+}
+
+export interface SlotValidationResult {
+  valid: boolean;
+  issues: SlotValidationIssue[];
+}
+
+// 금지된 import 모듈들
+const FORBIDDEN_IMPORTS = [
+  "fs",
+  "child_process",
+  "cluster",
+  "worker_threads",
+  "node:fs",
+  "node:child_process",
+  "node:cluster",
+  "node:worker_threads",
+];
+
+// 필수 패턴들
+const REQUIRED_PATTERNS = {
+  manduImport: /import\s+.*\bMandu\b.*from\s+['"]@mandujs\/core['"]/,
+  fillingPattern: /Mandu\s*\.\s*filling\s*\(\s*\)/,
+  defaultExport: /export\s+default\b/,
+};
+
+/**
+ * 슬롯 내용을 검증합니다.
+ */
+export function validateSlotContent(content: string): SlotValidationResult {
+  const issues: SlotValidationIssue[] = [];
+  const lines = content.split("\n");
+
+  // 1. 금지된 import 검사
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    for (const forbidden of FORBIDDEN_IMPORTS) {
+      // import 문에서 금지된 모듈 체크
+      const importPattern = new RegExp(
+        `import\\s+.*from\\s+['"]${forbidden.replace("/", "\\/")}['"]`
+      );
+      const requirePattern = new RegExp(
+        `require\\s*\\(\\s*['"]${forbidden.replace("/", "\\/")}['"]\\s*\\)`
+      );
+
+      if (importPattern.test(line) || requirePattern.test(line)) {
+        issues.push({
+          code: "FORBIDDEN_IMPORT",
+          severity: "error",
+          message: `금지된 모듈 import: '${forbidden}'`,
+          line: i + 1,
+          suggestion: `'${forbidden}' 대신 Bun의 안전한 API 또는 adapter를 사용하세요`,
+          autoFixable: true,
+        });
+      }
+    }
+  }
+
+  // 2. Mandu import 검사
+  if (!REQUIRED_PATTERNS.manduImport.test(content)) {
+    issues.push({
+      code: "MISSING_MANDU_IMPORT",
+      severity: "error",
+      message: "Mandu import가 없습니다",
+      suggestion: "import { Mandu } from '@mandujs/core' 추가 필요",
+      autoFixable: true,
+    });
+  }
+
+  // 3. Mandu.filling() 패턴 검사
+  if (!REQUIRED_PATTERNS.fillingPattern.test(content)) {
+    issues.push({
+      code: "MISSING_FILLING_PATTERN",
+      severity: "error",
+      message: "Mandu.filling() 패턴이 없습니다",
+      suggestion: "슬롯은 Mandu.filling()으로 시작해야 합니다",
+      autoFixable: false,
+    });
+  }
+
+  // 4. default export 검사
+  if (!REQUIRED_PATTERNS.defaultExport.test(content)) {
+    issues.push({
+      code: "MISSING_DEFAULT_EXPORT",
+      severity: "error",
+      message: "default export가 없습니다",
+      suggestion: "export default Mandu.filling()... 형태로 작성하세요",
+      autoFixable: true,
+    });
+  }
+
+  // 5. 기본 문법 검사 (간단한 체크)
+  const syntaxIssues = checkBasicSyntax(content, lines);
+  issues.push(...syntaxIssues);
+
+  // 6. HTTP 메서드 핸들러 검사
+  const methodIssues = checkHttpMethods(content);
+  issues.push(...methodIssues);
+
+  return {
+    valid: issues.filter((i) => i.severity === "error").length === 0,
+    issues,
+  };
+}
+
+/**
+ * 기본 문법 검사
+ */
+function checkBasicSyntax(
+  content: string,
+  lines: string[]
+): SlotValidationIssue[] {
+  const issues: SlotValidationIssue[] = [];
+
+  // 괄호 균형 체크
+  const brackets = { "(": 0, "{": 0, "[": 0 };
+  const bracketPairs: Record<string, keyof typeof brackets> = {
+    ")": "(",
+    "}": "{",
+    "]": "[",
+  };
+
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    // 문자열 내부는 스킵 (간단한 처리)
+    const withoutStrings = line
+      .replace(/"[^"]*"/g, "")
+      .replace(/'[^']*'/g, "")
+      .replace(/`[^`]*`/g, "");
+
+    for (const char of withoutStrings) {
+      if (char in brackets) {
+        brackets[char as keyof typeof brackets]++;
+      } else if (char in bracketPairs) {
+        brackets[bracketPairs[char]]--;
+      }
+    }
+  }
+
+  if (brackets["("] !== 0) {
+    issues.push({
+      code: "UNBALANCED_PARENTHESES",
+      severity: "error",
+      message: `괄호 불균형: ${brackets["("] > 0 ? "닫는" : "여는"} 괄호 부족`,
+      suggestion: "괄호 쌍을 확인하세요",
+      autoFixable: false,
+    });
+  }
+
+  if (brackets["{"] !== 0) {
+    issues.push({
+      code: "UNBALANCED_BRACES",
+      severity: "error",
+      message: `중괄호 불균형: ${brackets["{"] > 0 ? "닫는" : "여는"} 중괄호 부족`,
+      suggestion: "중괄호 쌍을 확인하세요",
+      autoFixable: false,
+    });
+  }
+
+  if (brackets["["] !== 0) {
+    issues.push({
+      code: "UNBALANCED_BRACKETS",
+      severity: "error",
+      message: `대괄호 불균형: ${brackets["["] > 0 ? "닫는" : "여는"} 대괄호 부족`,
+      suggestion: "대괄호 쌍을 확인하세요",
+      autoFixable: false,
+    });
+  }
+
+  return issues;
+}
+
+/**
+ * HTTP 메서드 핸들러 검사
+ */
+function checkHttpMethods(content: string): SlotValidationIssue[] {
+  const issues: SlotValidationIssue[] = [];
+
+  // .get(), .post() 등의 핸들러가 있는지 확인
+  const methodPattern = /\.(get|post|put|patch|delete|options|head)\s*\(/gi;
+  const hasMethod = methodPattern.test(content);
+
+  if (!hasMethod) {
+    issues.push({
+      code: "NO_HTTP_HANDLER",
+      severity: "warning",
+      message: "HTTP 메서드 핸들러가 없습니다",
+      suggestion:
+        ".get(ctx => ...), .post(ctx => ...) 등의 핸들러를 추가하세요",
+      autoFixable: false,
+    });
+  }
+
+  // ctx.ok(), ctx.json() 등 응답 패턴 확인
+  const responsePattern = /ctx\s*\.\s*(ok|json|created|noContent|error|html)\s*\(/;
+  if (hasMethod && !responsePattern.test(content)) {
+    issues.push({
+      code: "NO_RESPONSE_PATTERN",
+      severity: "warning",
+      message: "응답 패턴이 없습니다",
+      suggestion:
+        "핸들러에서 ctx.ok(), ctx.json() 등으로 응답을 반환하세요",
+      autoFixable: false,
+    });
+  }
+
+  return issues;
+}
+
+/**
+ * 에러 요약 생성
+ */
+export function summarizeValidationIssues(
+  issues: SlotValidationIssue[]
+): string {
+  const errors = issues.filter((i) => i.severity === "error");
+  const warnings = issues.filter((i) => i.severity === "warning");
+
+  const parts: string[] = [];
+
+  if (errors.length > 0) {
+    parts.push(`${errors.length}개 에러`);
+  }
+  if (warnings.length > 0) {
+    parts.push(`${warnings.length}개 경고`);
+  }
+
+  return parts.join(", ") || "문제 없음";
+}