sonamu 0.9.5 → 0.9.6

package/src/utils/formatter.ts

@@ -1,108 +1,147 @@
-import { execFileSync } from "child_process";
-import { readFileSync, unlinkSync, writeFileSync } from "fs";
+import { createHash } from "crypto";
+// 테스트 환경에서는 fs/promises가 mock되지만, 아래 runOxlint이 isTest 가드로 안 도니까
+// 그냥 fs/promises 그대로 사용. (production에서만 임시파일 흐름이 돕니다.)
+import { readFile, unlink, writeFile } from "fs/promises";
 import { createRequire } from "module";
-import { join } from "path";
+import { tmpdir } from "os";
+import path, { dirname, join } from "path";
 
-import { format } from "oxfmt";
+import { format, type FormatConfig } from "oxfmt";
 
+import { cached } from "./async-utils";
 import { isTest } from "./controller";
+import { execute } from "./process-utils";
 
 const _require = createRequire(import.meta.url);
 
-const OXFMT_OPTIONS = {
-  printWidth: 100,
-  tabWidth: 2,
-  useTabs: false,
-  singleQuote: false,
-  jsxSingleQuote: false,
-  trailingComma: "all" as const,
-  semi: true,
-  endOfLine: "lf" as const,
-  bracketSpacing: true,
-  sortImports: true,
-};
+/**
+ * 코드를 프로젝트의 oxfmt + oxlint 설정에 맞춰 포매팅한 문자열을 반환합니다.
+ *
+ * 캐싱도 있어요 ㅎㅎ 똑같은 입력에 대해서 캐시 커버됩니다.
+ * 수명은 프로세스 죽을때까지 ㅋ
+ */
+export const formatCode = cached(formatCodeInternal, (code, filePath) => {
+  const ext = filePath.endsWith(".tsx") ? "tsx" : filePath.endsWith("json") ? "json" : "ts";
+  return `${ext}:${createHash("sha1").update(code).digest("hex")}`;
+});
 
-function resolveOxlintBin(): string {
-  try {
-    return _require.resolve("oxlint/bin/oxlint");
-  } catch {
-    return "oxlint";
+/**
+ * 캐시 없는 포맷함수 엔트리.
+ */
+async function formatCodeInternal(code: string, filePath: string): Promise<string> {
+  // json은 포맷만 하면 됩니다.
+  if (filePath.endsWith("json")) {
+    return runOxfmt(code, filePath);
   }
+
+  // 린트 먼저 한 다음에 포맷으로 마무리해요.
+  return runOxfmt(await runOxlint(code), filePath);
 }
 
-export async function formatCode(
-  code: string,
-  parser: "typescript" | "json",
-  _filePath: string,
-): Promise<string> {
-  const fileName = parser === "json" ? "file.json" : "file.ts";
-
-  // oxfmt 포맷팅
-  const formatted = await format(fileName, code, OXFMT_OPTIONS);
-  if (formatted.errors.length > 0) {
-    const errorMessages = formatted.errors
-      .filter((e) => e.severity === "Error")
-      .map((e) => e.message);
-    if (errorMessages.length > 0) {
-      // 파싱 에러가 있는 코드는 포맷팅 없이 원본 반환 (Biome formatWithErrors: false와 동일)
-      return code;
+/**
+ * 프로젝트 설정을 찾아서 이에 맞춰서 코드를 포맷합니다.
+ */
+async function runOxfmt(code: string, filePath: string): Promise<string> {
+  const result = await format(path.basename(filePath), code, await loadOxfmtConfig());
+
+  const errors = result.errors.filter((e) => e.severity === "Error");
+  if (errors.length > 0) {
+    if (!isTest()) {
+      console.error(`oxfmt errors (${filePath}):`);
+      for (const err of errors) {
+        const label = err.labels[0];
+        if (label) {
+          const before = code.slice(Math.max(0, label.start - 80), label.start);
+          const at = code.slice(label.start, label.end);
+          const after = code.slice(label.end, Math.min(code.length, label.end + 80));
+          console.error(`  - ${err.message} (offset ${label.start}-${label.end})`);
+          console.error(`    around: ...${before}»${at}«${after}...`);
+        } else {
+          console.error(`  - ${err.message}`);
+        }
+      }
+    }
+    return code;
+  }
+  return result.code;
+}
+
+let cachedOxfmtConfig: FormatConfig | null = null;
+async function loadOxfmtConfig(): Promise<FormatConfig> {
+  if (cachedOxfmtConfig !== null) {
+    return cachedOxfmtConfig;
+  }
+
+  let dir = process.cwd();
+  while (true) {
+    const candidate = join(dir, ".oxfmtrc.json");
+    try {
+      cachedOxfmtConfig = JSON.parse(await readFile(candidate, "utf-8")) as FormatConfig;
+      return cachedOxfmtConfig;
+    } catch (e) {
+      if ((e as NodeJS.ErrnoException).code !== "ENOENT") {
+        !isTest() && console.error(`Failed to load ${candidate}:`, e);
+        break;
+      }
     }
+    const parent = dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
   }
 
-  // JSON은 포맷팅만 수행
-  if (parser === "json") {
-    return formatted.code;
+  cachedOxfmtConfig = {};
+  return cachedOxfmtConfig;
+}
+
+/**
+ * 프로젝트 설정에 맞춰 코드를 lint합니다.
+ *
+ * 프로젝트 설정을 적용받는 oxlint cli를 찾아 띄워서,
+ * 임시 파일에 in-place로 써서 그 결과를 빼오는 방식으로 작동합니다.
+ * 왜 이렇게 하느냐? oxlint가 node api도 안 주고 cli에서 stdin 옵션도 안 주기 때문...
+ */
+async function runOxlint(code: string): Promise<string> {
+  if (isTest()) {
+    // 테스트 환경에서는 느려지기만 하고 검증할 가치도 없어서 안 합니다.
+    // GitHub Actions 환경에서 lint가 오래 걸려서 뻗기도 했어요. (https://github.com/cartanova-ai/sonamu/actions/runs/25267214027/job/74083630169)
+    return code;
   }
 
-  // TypeScript: oxlint --fix로 lint fix 수행 (unused import 제거, type import 변환 등)
-  // cwd 아래에 생성해야 nested config(.oxlintrc.json)과 tsconfig를 찾을 수 있음
+  // OS tmp dir에 두는 이유: process.cwd()가 watcher 스코프(api/src 아래)일 가능성을 차단합니다.
+  // cwd가 그 위치라면 write/unlink가 짧은 순간 watcher 이벤트로 잡혀 batch에 흘러들어갈 수 있어요.
   const tmpFile = join(
-    process.cwd(),
+    tmpdir(),
     `.sonamu-fmt-${Date.now()}-${Math.random().toString(36).slice(2)}.ts`,
   );
+
   try {
-    writeFileSync(tmpFile, formatted.code, "utf-8");
+    await writeFile(tmpFile, code, "utf-8");
 
-    const oxlintBin = resolveOxlintBin();
     try {
-      execFileSync(oxlintBin, ["--fix", "--fix-suggestions", "--type-aware", tmpFile], {
-        stdio: "pipe",
+      await execute(resolveOxlintBin(), ["--fix", "--fix-suggestions", "--type-aware", tmpFile], {
         timeout: 10000,
       });
-    } catch (execError: unknown) {
-      // oxlint은 lint 에러가 있으면 exit code != 0으로 종료하지만 --fix는 적용됨
-      if (execError instanceof Error) {
-        const errObj = execError as Error & { status?: number | null; code?: string };
-        if (typeof errObj.status === "number") {
-          void errObj.status;
-        } else {
-          throw execError;
-        }
-      } else {
-        throw execError;
-      }
-    }
-
-    const lintFixed = readFileSync(tmpFile, "utf-8");
-
-    // lint fix 후 재포맷 (import 구문 변경으로 인한 정렬 등)
-    const reformatted = await format(fileName, lintFixed, OXFMT_OPTIONS);
-    if (reformatted.errors.length > 0) {
-      const errorMessages = reformatted.errors
-        .filter((e) => e.severity === "Error")
-        .map((e) => e.message);
-      if (errorMessages.length > 0) {
-        !isTest() && console.error("oxfmt reformat errors:", errorMessages);
-        throw new Error(`oxfmt reformat error: ${errorMessages.join(", ")}`);
+    } catch (e) {
+      // lint 위반 시 exit code != 0이지만 --fix는 적용됨. exec 자체 실패만 throw.
+      if (typeof (e as Error & { code?: number }).code !== "number") {
+        throw e;
       }
     }
 
-    return reformatted.code;
+    return await readFile(tmpFile, "utf-8");
   } finally {
     try {
-      unlinkSync(tmpFile);
+      await unlink(tmpFile);
     } catch {
-      // 임시 파일 정리 실패는 무시
+      // 삭제 실패해도 어차피 ignore됨.
     }
   }
 }
+
+function resolveOxlintBin(): string {
+  try {
+    return _require.resolve("oxlint/bin/oxlint");
+  } catch {
+    return "oxlint";
+  }
+}

package/src/utils/fs-utils.ts

@@ -3,6 +3,8 @@ import { type PathLike } from "fs";
 import { access, readFile, stat, writeFile } from "fs/promises";
 import path, { dirname } from "path";
 
+import { formatCode } from "./formatter";
+
 /**
  * fs/promises에는 exists가 없어요. 대신 access가 있습니다.
  * 근데 얘는 인터페이스가 쓰기 불편해요. 그래서 감싸주었습니다.
@@ -37,6 +39,8 @@ export async function fileExists(path: PathLike): Promise<boolean> {
  * - services/user/user.types.ts → ../sonamu.shared
  * - i18n/ko.ts → ../services/sonamu.shared
  *
+ * ts/tsx 파일은 쓰기 전에 oxfmt/oxlint 한번 돌려줍니다!
+ *
  * @param fromPath 원본 파일 경로
  * @param toPath 대상 파일 경로
  * @param syncHeader 동기화 시 파일 최상단에 삽입할 주석 블록. 기존 @generated 블록이 있으면 교체하고, 없으면 최상단에 추가합니다.
@@ -83,6 +87,11 @@ export async function copyFileWithReplaceCoreToShared(
     }
   }
 
+  // .ts/.tsx 산출물은 쓰기 전에 포맷도 해줘요 ㅎㅎ
+  if (toPath.endsWith(".ts") || toPath.endsWith(".tsx")) {
+    newFileContent = await formatCode(newFileContent, toPath);
+  }
+
   await writeFile(toPath, newFileContent);
   return true;
 }

package/src/utils/process-utils.ts

@@ -1,7 +1,24 @@
+import { execFile, type ExecFileOptions } from "child_process";
 import { setTimeout as setTimeoutPromises } from "timers/promises";
+import { promisify } from "util";
 
 import chalk from "chalk";
 
+const execFileAsync = promisify(execFile);
+
+/**
+ * exexFileSync의 비동기 버전입니다.
+ * exit code가 non-zero이면 reject해요.
+ */
+export async function execute(
+  bin: string,
+  args: string[],
+  options?: ExecFileOptions,
+): Promise<string> {
+  const { stdout } = await execFileAsync(bin, args, options);
+  return typeof stdout === "string" ? stdout : stdout.toString();
+}
+
 /**
  * 주어진 작업을 실행합니다.
  * 주어진 프로세스 이벤트(=시그널)가 발생하였을 때에도 최대 한계(delayBeforeShutdown) 동안 작업을 기다린 후 종료합니다.

package/src/utils/utils.ts

@@ -118,7 +118,7 @@ export function merge<T extends Record<string, any>>(defaultObj: T, userObj: T):
 
 // plain object 판별 헬퍼 함수
 // (배열, null, Date 등을 제외한 순수 객체만 true)
-function isPlainObject(value: unknown): value is Record<string, unknown> {
+export function isPlainObject(value: unknown): value is Record<string, unknown> {
   return (
     value !== null &&
     typeof value === "object" &&