sonamu 0.8.26 → 0.9.0

package/src/ui/cdd-service.ts

@@ -2,18 +2,19 @@ import { spawn } from "child_process";
 import fs from "fs";
 import os from "os";
 import path from "path";
+
 import { Sonamu } from "../api/sonamu";
-import type {
-  CddAcEntry,
-  CddAcFile,
-  CddAcListResult,
-  CddAddRuleRequest,
-  CddContentResult,
-  CddFileType,
-  CddRuleDetail,
-  CddRuleEntry,
-  CddRuleSummary,
-  CddTreeNode,
+import {
+  type CddAcEntry,
+  type CddAcFile,
+  type CddAcListResult,
+  type CddAddRuleRequest,
+  type CddContentResult,
+  type CddFileType,
+  type CddRuleDetail,
+  type CddRuleEntry,
+  type CddRuleSummary,
+  type CddTreeNode,
 } from "./cdd-types";
 
 export type {

package/src/utils/console-util.ts

@@ -1,5 +1,7 @@
+import { spawn } from "child_process";
+import { type ChildProcess } from "child_process";
+
 import chalk from "chalk";
-import { type ChildProcess, spawn } from "child_process";
 
 const DEFAULT_LINE_PREFIX = "  │    ";
 

package/src/utils/formatter.ts

@@ -1,116 +1,108 @@
-import { Biome } from "@biomejs/js-api/nodejs";
-import { Naite } from "../naite/naite";
+import { execFileSync } from "child_process";
+import { readFileSync, unlinkSync, writeFileSync } from "fs";
+import { createRequire } from "module";
+import { join } from "path";
+
+import { format } from "oxfmt";
+
 import { isTest } from "./controller";
 
-const biome = new Biome();
-let projectKey: number = -1;
+const _require = createRequire(import.meta.url);
 
-export function setupBiome(path: string) {
-  if (projectKey !== -1) {
-    return;
-  }
+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,
+};
 
-  projectKey = biome.openProject(path).projectKey;
-  biome.applyConfiguration(projectKey, {
-    formatter: {
-      enabled: true,
-      formatWithErrors: false,
-      indentStyle: "space",
-      indentWidth: 2,
-      lineEnding: "lf",
-      lineWidth: 100,
-      attributePosition: "auto",
-    },
-    linter: {
-      enabled: true,
-      rules: {
-        recommended: true,
-        style: {
-          useNodejsImportProtocol: "off",
-        },
-        correctness: {
-          useParseIntRadix: "off",
-          noEmptyPattern: "off",
-          noUnusedImports: {
-            level: "warn",
-            fix: "safe",
-          },
-        },
-        a11y: {
-          noLabelWithoutControl: "off",
-        },
-        complexity: {
-          noBannedTypes: "off",
-        },
-        suspicious: {
-          noArrayIndexKey: "off",
-        },
-      },
-    },
-    javascript: {
-      formatter: {
-        jsxQuoteStyle: "double",
-        quoteProperties: "asNeeded",
-        trailingCommas: "all",
-        semicolons: "always",
-        arrowParentheses: "always",
-        bracketSpacing: true,
-        bracketSameLine: false,
-        quoteStyle: "double",
-        attributePosition: "auto",
-      },
-    },
-    json: {
-      formatter: {
-        indentWidth: 2,
-      },
-    },
-    assist: {
-      enabled: true,
-      actions: {
-        source: {
-          organizeImports: "on",
-        },
-      },
-    },
-  });
+function resolveOxlintBin(): string {
+  try {
+    return _require.resolve("oxlint/bin/oxlint");
+  } catch {
+    return "oxlint";
+  }
 }
 
-export function formatCode(code: string, parser: "typescript" | "json", filePath: string) {
-  Naite.t("formatCode", { code, parser });
+export async function formatCode(
+  code: string,
+  parser: "typescript" | "json",
+  _filePath: string,
+): Promise<string> {
+  const fileName = parser === "json" ? "file.json" : "file.ts";
 
-  if (projectKey === -1) {
-    console.warn("Biome is not setup. Please call setupBiome first.");
-    return code;
+  // 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;
+    }
   }
 
-  // 포맷팅을 먼저 해야함
-  const formatted = biome.formatContent(projectKey, code, { filePath });
-  Naite.t("formatCode:formatted", formatted);
-  if (formatted.diagnostics.filter((d) => d.severity === "error").length > 0) {
-    console.error(formatted.diagnostics);
-    throw new Error("Biome format error");
+  // JSON은 포맷팅만 수행
+  if (parser === "json") {
+    return formatted.code;
   }
 
-  // 린팅을 그 다음에
-  const linted = biome.lintContent(projectKey, formatted.content, {
-    filePath,
-    fixFileMode: "safeAndUnsafeFixes",
-  });
-  if (linted.diagnostics.filter((d) => d.severity === "error").length > 0) {
-    Naite.t("formatCode:linted:content", linted.content);
-    Naite.t("formatCode:linted:diagnostics", linted.diagnostics);
-    !isTest() && console.dir(linted.diagnostics, { depth: null });
-    throw new Error("Biome lint error");
-  }
-  Naite.t("formatCode:linted", linted);
+  // TypeScript: oxlint --fix로 lint fix 수행 (unused import 제거, type import 변환 등)
+  // cwd 아래에 생성해야 nested config(.oxlintrc.json)과 tsconfig를 찾을 수 있음
+  const tmpFile = join(
+    process.cwd(),
+    `.sonamu-fmt-${Date.now()}-${Math.random().toString(36).slice(2)}.ts`,
+  );
+  try {
+    writeFileSync(tmpFile, formatted.code, "utf-8");
 
-  // 포맷팅 한 번 더 (import 구문에 type 키워드 추가되는 경우 maxWidth 초과로 인한 에러 발생)
-  const formattedAgain = biome.formatContent(projectKey, linted.content, { filePath });
-  if (formattedAgain.diagnostics.filter((d) => d.severity === "error").length > 0) {
-    console.error(formattedAgain.diagnostics);
-    throw new Error("Biome format error");
-  }
+    const oxlintBin = resolveOxlintBin();
+    try {
+      execFileSync(oxlintBin, ["--fix", "--fix-suggestions", "--type-aware", tmpFile], {
+        stdio: "pipe",
+        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");
 
-  return formattedAgain.content;
+    // 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(", ")}`);
+      }
+    }
+
+    return reformatted.code;
+  } finally {
+    try {
+      unlinkSync(tmpFile);
+    } catch {
+      // 임시 파일 정리 실패는 무시
+    }
+  }
 }

package/src/utils/fs-utils.ts

@@ -1,4 +1,5 @@
-import { constants, type PathLike } from "fs";
+import { constants } from "fs";
+import { type PathLike } from "fs";
 import { access, readFile, stat, writeFile } from "fs/promises";
 import path, { dirname } from "path";
 

package/src/utils/model.ts

@@ -1,4 +1,4 @@
-import type { SonamuQueryMode } from "..";
+import { type SonamuQueryMode } from "../types/types";
 
 // semanticQuery가 있으면 similarity를 추가하는 조건부 타입
 type WithSimilarity<LP, T> = LP extends { semanticQuery: Record<string, unknown> }
@@ -20,7 +20,7 @@ export function asArray<T>(param: T | T[]): T[] {
   if (Array.isArray(param)) {
     return param;
   } else {
-    return [param as T] as T[];
+    return [param] as T[];
   }
 }
 

package/src/utils/object-utils.ts

@@ -21,11 +21,11 @@ type NonSerializable =
   | Promise<unknown>
   | RegExp
   | symbol
-  // biome-ignore lint/suspicious/noExplicitAny: WeakMap의 제네릭 파라미터
+  // oxlint-disable-next-line @typescript-eslint/no-explicit-any -- WeakMap의 제네릭 파라미터
   | WeakMap<any, any>
-  // biome-ignore lint/suspicious/noExplicitAny: WeakSet의 제네릭 파라미터
+  // oxlint-disable-next-line @typescript-eslint/no-explicit-any -- WeakSet의 제네릭 파라미터
   | WeakSet<any>
-  // biome-ignore lint/suspicious/noExplicitAny: WeakRef의 제네릭 파라미터
+  // oxlint-disable-next-line @typescript-eslint/no-explicit-any -- WeakRef의 제네릭 파라미터
   | WeakRef<any>;
 
 /** 재귀적 직렬화 가능 타입 */

package/src/utils/process-utils.ts

@@ -1,6 +1,7 @@
-import chalk from "chalk";
 import { setTimeout as setTimeoutPromises } from "timers/promises";
 
+import chalk from "chalk";
+
 /**
  * 주어진 작업을 실행합니다.
  * 주어진 프로세스 이벤트(=시그널)가 발생하였을 때에도 최대 한계(delayBeforeShutdown) 동안 작업을 기다린 후 종료합니다.

package/src/utils/sql-parser.ts

@@ -1,5 +1,14 @@
-import type { AST, ColumnRef, Expr, ExpressionValue, From, Join, Select } from "node-sql-parser";
+import {
+  type AST,
+  type ColumnRef,
+  type Expr,
+  type ExpressionValue,
+  type From,
+  type Join,
+  type Select,
+} from "node-sql-parser";
 import { unique } from "radashi";
+
 import { nonNullable } from "./utils";
 
 export function getTableName(expr: ColumnRef) {

package/src/utils/type-utils.ts

@@ -31,7 +31,7 @@ export function withProp<T extends object, P extends string, V>(
   if (keys.length === 0) throw new Error("Path cannot be empty");
   const result = structuredClone(obj);
 
-  // biome-ignore lint/suspicious/noExplicitAny: 범용 배열 요소 타입
+  // oxlint-disable-next-line @typescript-eslint/no-explicit-any -- 범용 배열 요소 타입
   const setDeep = (current: any, keys: string[], value: V): void => {
     if (keys.length === 0) return;
     const [key, ...rest] = keys;
@@ -49,7 +49,7 @@ export function withProp<T extends object, P extends string, V>(
         current[key] = {};
       }
       if (Array.isArray(current[key])) {
-        // biome-ignore lint/suspicious/noExplicitAny: 범용 배열 요소 타입
+        // oxlint-disable-next-line @typescript-eslint/no-explicit-any -- 범용 배열 요소 타입
         current[key].forEach((item: any) => {
           setDeep(item, rest, value);
         });
@@ -78,7 +78,7 @@ export function withProps<T extends object>(obj: T): ChainWrapper<T> {
   return {
     set: <P extends string, V>(path: P, value: V) => {
       const nextObj = withProp(obj, path, value);
-      return withProps(nextObj) as ChainWrapper<SetPath<T, P, V>>;
+      return withProps(nextObj);
     },
     value: () => obj,
   };

package/src/utils/utils.ts

@@ -1,8 +1,9 @@
-import type { FastifyRequest } from "fastify";
 import fs from "fs";
 import path from "path";
-import { cluster } from "radashi";
-import type { AbsolutePath } from "./path-utils";
+
+import { type FastifyRequest } from "fastify";
+
+import { type AbsolutePath } from "./path-utils";
 
 export function findAppRootPath(): AbsolutePath {
   const apiRootPath = findApiRootPath();
@@ -21,6 +22,11 @@ export function findApiRootPath(): AbsolutePath {
     return process.cwd().split(path.sep).join(path.sep) as AbsolutePath;
   }
 
+  const cwdPackagePath = path.join(process.cwd(), "package.json");
+  if (fs.existsSync(cwdPackagePath)) {
+    return process.cwd().split(path.sep).join(path.sep) as AbsolutePath;
+  }
+
   const basePath = import.meta.filename;
   let dir = path.dirname(basePath);
   if (dir.includes("/.yarn/")) {
@@ -67,10 +73,6 @@ export function assertDefined<T>(value: T | undefined, message?: string): T {
   return value;
 }
 
-// lodash chunk 대체 (radash cluster 사용)
-export function chunk<T>(array: T[], size: number): T[][] {
-  return cluster(array, Math.ceil(array.length / size));
-}
 // lodash intersectionBy 대체
 export function intersectionBy<T, K>(
   arr1: readonly T[],

package/src/utils/zod-error.ts

@@ -1,4 +1,4 @@
-import type { z } from "zod";
+import { type z } from "zod";
 
 type ValidationError = {
   path: string[];

package/src/vector/chunking.ts

@@ -1,5 +1,5 @@
 import { DEFAULT_VECTOR_CONFIG } from "./config";
-import type { Chunk, ChunkingConfig } from "./types";
+import { type Chunk, type ChunkingConfig } from "./types";
 
 /**
  * 텍스트 청킹

package/src/vector/config.ts

@@ -1,4 +1,4 @@
-import type { VectorConfig } from "./types";
+import { type VectorConfig } from "./types";
 
 /**
  * 벡터 검색 기본 설정

package/src/vector/embedding.ts

@@ -1,14 +1,16 @@
-import type { OpenAIProvider } from "@ai-sdk/openai";
-import { type EmbeddingModel, embedMany } from "ai";
-import type { VoyageAIClient } from "voyageai";
+import { type OpenAIProvider } from "@ai-sdk/openai";
+import { embedMany } from "ai";
+import { type EmbeddingModel } from "ai";
+import { type VoyageAIClient } from "voyageai";
+
 import { Sonamu } from "../api/sonamu";
 import { DEFAULT_VECTOR_CONFIG } from "./config";
-import type {
-  EmbeddingProvider,
-  EmbeddingResult,
-  ProgressCallback,
-  VectorConfig,
-  VectorInputType,
+import {
+  type EmbeddingProvider,
+  type EmbeddingResult,
+  type ProgressCallback,
+  type VectorConfig,
+  type VectorInputType,
 } from "./types";
 
 /**

package/tsdown.api.config.ts

@@ -0,0 +1,50 @@
+import { readdirSync, statSync } from "node:fs";
+import path from "node:path";
+
+import { defineConfig } from "tsdown";
+
+const srcRoot = path.resolve(process.cwd(), "src");
+const ignoredSuffixes = [".test.ts", ".test-hold.ts", ".ignore.ts", ".d.ts"];
+const ignoredDirectories = new Set(["__mocks__", "_templates", "wasted_src"]);
+
+function collectEntries(directory: string): Record<string, string> {
+  const entries: Record<string, string> = {};
+
+  for (const entry of readdirSync(directory)) {
+    if (ignoredDirectories.has(entry)) {
+      continue;
+    }
+
+    const absolutePath = path.join(directory, entry);
+    const stats = statSync(absolutePath);
+
+    if (stats.isDirectory()) {
+      Object.assign(entries, collectEntries(absolutePath));
+      continue;
+    }
+
+    if (
+      !absolutePath.endsWith(".ts") ||
+      ignoredSuffixes.some((suffix) => absolutePath.endsWith(suffix))
+    ) {
+      continue;
+    }
+
+    const relativePath = path.relative(srcRoot, absolutePath);
+    const entryName = relativePath.replace(/\.ts$/, "").split(path.sep).join("/");
+    entries[entryName] = absolutePath;
+  }
+
+  return entries;
+}
+
+export default defineConfig({
+  clean: true,
+  entry: collectEntries(srcRoot),
+  format: "esm",
+  platform: "node",
+  sourcemap: "inline",
+  target: "esnext",
+  treeshake: false,
+  unbundle: true,
+});

package/.swcrc.project-default

@@ -1,18 +0,0 @@
-{
-  "$schema": "https://swc.rs/schema.json",
-  "module": {
-    "type": "es6", // import/export 쓰는 esm으로 가겠습니다.
-    "resolveFully": true // esm이 요구하는 대로, 임포트 경로를 실제 파일 경로(확장자 포함)로 풀어줍니다.
-  },
-  "jsc": {
-    "parser": {
-      "syntax": "typescript",
-      "decorators": true
-    },
-    "baseUrl": ".", // 위 resolveFully 옵션이 작동하려면 이게 필요합니다. 이 파일이 있는 로컬에서 쉘에 직접 실행할 때에는 baseUrl에 이 파일이 위치한 경로 기준으로 절대경로가 resolve되어 들어갑니다. 그러나 만약 swc를 코드 상에서 import해서 쓰거나, 아니면 설정 파일(.swcrc) 대신 -C로 설정을 명령줄에 직접 넘기는 경우, baseUrl에 직접 올바른 절대경로를 넣어주어야 합니다.
-    "target": "esnext" // 타겟은 그냥 최신 문법으로.
-  },
-  "minify": false, // 어차피 용량 10%정도 차이밖에 안 남. minify를 끄면 혹시 혹시 정말 혹시나 나중에 소스맵 없이 코드를 봐야 하는 끔찍한 상황에 조금이나마 도움이 될 수 있지 않을까 해서 끔.
-  "sourceMaps": "inline", // 인라인 소스맵 생성 - yarn PnP 가상 경로 문제 해결
-  "inlineSourcesContent": true // 소스 코드를 소스맵에 포함
-}