sonamu 0.11.11 → 0.11.13

package/dist/code-formatting/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * 코드를 프로젝트의 oxfmt + oxlint 설정에 맞춰 포매팅한 문자열을 반환합니다.
+ *
+ * 캐싱도 있어요 ㅎㅎ 똑같은 입력에 대해서 캐시 커버됩니다.
+ * 수명은 프로세스 죽을때까지 ㅋ
+ */
+export declare const formatCode: (code: string, filePath: string) => Promise<string>;
+//# sourceMappingURL=index.d.ts.map

package/dist/code-formatting/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/code-formatting/index.ts"],"names":[],"mappings":"AAMA;;;;;GAKG;AACH,eAAO,MAAM,UAAU,qDAGrB,CAAC"}

package/dist/code-formatting/index.js

@@ -0,0 +1,27 @@
+import { __esmMin } from "../_virtual/_rolldown/runtime.js";
+import { cached, init_async_utils } from "../utils/async-utils.js";
+import { init_oxfmt, runOxfmt } from "./oxfmt.js";
+import { init_oxlint, runOxlint } from "./oxlint.js";
+import { createHash } from "node:crypto";
+//#region src/code-formatting/index.ts
+/**
+* 캐시 없는 포맷함수 엔트리.
+*/
+async function formatCodeInternal(code, filePath) {
+	if (filePath.endsWith(".json")) return runOxfmt(code, filePath);
+	return runOxfmt(await runOxlint(code), filePath);
+}
+var formatCode;
+var init_code_formatting = __esmMin((() => {
+	init_async_utils();
+	init_oxfmt();
+	init_oxlint();
+	formatCode = cached(formatCodeInternal, (code, filePath) => {
+		return `${filePath.endsWith(".tsx") ? "tsx" : filePath.endsWith(".json") ? "json" : "ts"}:${createHash("sha1").update(code).digest("hex")}`;
+	});
+}));
+//#endregion
+init_code_formatting();
+export { formatCode, init_code_formatting };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/code-formatting/oxfmt.d.ts

@@ -0,0 +1,5 @@
+/**
+ * 프로젝트 설정을 찾아서 이에 맞춰서 코드를 포맷합니다.
+ */
+export declare function runOxfmt(code: string, filePath: string): Promise<string>;
+//# sourceMappingURL=oxfmt.d.ts.map

package/dist/code-formatting/oxfmt.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"oxfmt.d.ts","sourceRoot":"","sources":["../../src/code-formatting/oxfmt.ts"],"names":[],"mappings":"AAOA;;GAEG;AACH,wBAAsB,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAuB9E"}

package/dist/code-formatting/oxfmt.js

@@ -0,0 +1,61 @@
+import { __esmMin } from "../_virtual/_rolldown/runtime.js";
+import { init_controller, isTest } from "../utils/controller.js";
+import { readFile } from "node:fs/promises";
+import path, { dirname, join } from "node:path";
+import { format } from "oxfmt";
+//#region src/code-formatting/oxfmt.ts
+/**
+* 프로젝트 설정을 찾아서 이에 맞춰서 코드를 포맷합니다.
+*/
+async function runOxfmt(code, filePath) {
+	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;
+}
+async function loadOxfmtConfig() {
+	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"));
+			return cachedOxfmtConfig;
+		} catch (e) {
+			if (e.code !== "ENOENT") {
+				!isTest() && console.error(`Failed to load ${candidate}:`, e);
+				break;
+			}
+		}
+		const parent = dirname(dir);
+		if (parent === dir) break;
+		dir = parent;
+	}
+	cachedOxfmtConfig = {};
+	return cachedOxfmtConfig;
+}
+var cachedOxfmtConfig;
+var init_oxfmt = __esmMin((() => {
+	init_controller();
+	cachedOxfmtConfig = null;
+}));
+//#endregion
+init_oxfmt();
+export { init_oxfmt, runOxfmt };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/code-formatting/oxlint.d.ts

@@ -0,0 +1,30 @@
+export type ResolveOxlintBinOptions = {
+    resolveModule: (specifier: string) => string;
+    readFile: (filePath: string) => Promise<string>;
+    access: (filePath: string, mode: number) => Promise<void>;
+};
+/**
+ * 프로젝트 설정에 맞춰 코드를 lint합니다.
+ *
+ * 프로젝트 설정을 적용받는 oxlint cli를 찾아 띄워서,
+ * 임시 파일에 in-place로 써서 그 결과를 빼오는 방식으로 작동합니다.
+ * 왜 이렇게 하느냐? oxlint가 node api도 안 주고 cli에서 stdin 옵션도 안 주기 때문...
+ *
+ * 그런데 이 친구는 호출할 때마다 무지성으로 oxlint cli를 돌리지는 않습니다.
+ * 그런 식으로 했다가는 oxlint 프로세스만 동시에 수십 개가 떠 있게 될 수도 있어요.
+ * 그러다가 sync에서 파일 생성이 10초도 넘게 걸리는 일도 있었습니다.
+ * 이를 막기 위해, oxlint가 돌아가고 있을 때에 새 runOxlint 호출이 들어오면 내부에서 알아서 잘 쟁여놨다가 실행 끝나면 배치로 굴립니다.
+ * 한 번에 오직 하나의 oxlint cli 실행만 돌아가게 하는 겁니다.
+ *
+ * 자세한 배칭 전략:
+ * - 아무 것도 없을 때에 호출되면 바로 oxlint 실행합니다.
+ * - oxlint 실행 중에 들어오면 큐에 쟁여둡니다.
+ * - oxlint 실행 완료 시점에서 큐에 뭐가 있으면 그걸로 다음 배치 바로 실행합니다.
+ *
+ * 그래서 띄엄띄엄 하나씩 들어오면 그냥 순차 실행과 다름이 없고, 여러개 우루루 들어오면 그때 효용이 생깁니다.
+ * 다만 동시에 30개가 한번에 들어온다고 30개가 모두 한 배치를 타지는 않고,
+ * idle에서의 첫 요청에 즉시 배치를 시작하므로 최소 2배치가 소요된다는 점 주의염.
+ */
+export declare function runOxlint(code: string): Promise<string>;
+export declare function resolveOxlintBin(options?: ResolveOxlintBinOptions): Promise<string>;
+//# sourceMappingURL=oxlint.d.ts.map

package/dist/code-formatting/oxlint.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"oxlint.d.ts","sourceRoot":"","sources":["../../src/code-formatting/oxlint.ts"],"names":[],"mappings":"AAeA,MAAM,MAAM,uBAAuB,GAAG;IACpC,aAAa,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,MAAM,CAAC;IAC7C,QAAQ,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,CAAC,CAAC;IAChD,MAAM,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;CAC3D,CAAC;AAkBF;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAsB,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAwB7D;AAgDD,wBAAsB,gBAAgB,CACpC,OAAO,GAAE,uBAIR,GACA,OAAO,CAAC,MAAM,CAAC,CA4CjB"}

package/dist/code-formatting/oxlint.js

@@ -0,0 +1,130 @@
+import { __esmMin } from "../_virtual/_rolldown/runtime.js";
+import { init_runtime_value, isNumberValue } from "../utils/runtime-value.js";
+import { init_controller, isTest } from "../utils/controller.js";
+import { execute, init_process_utils } from "../utils/process-utils.js";
+import { createRequire } from "node:module";
+import { z } from "zod";
+import { access, readFile, unlink, writeFile } from "node:fs/promises";
+import path, { dirname, join } from "node:path";
+import { constants } from "node:fs";
+//#region src/code-formatting/oxlint.ts
+/**
+* 프로젝트 설정에 맞춰 코드를 lint합니다.
+*
+* 프로젝트 설정을 적용받는 oxlint cli를 찾아 띄워서,
+* 임시 파일에 in-place로 써서 그 결과를 빼오는 방식으로 작동합니다.
+* 왜 이렇게 하느냐? oxlint가 node api도 안 주고 cli에서 stdin 옵션도 안 주기 때문...
+*
+* 그런데 이 친구는 호출할 때마다 무지성으로 oxlint cli를 돌리지는 않습니다.
+* 그런 식으로 했다가는 oxlint 프로세스만 동시에 수십 개가 떠 있게 될 수도 있어요.
+* 그러다가 sync에서 파일 생성이 10초도 넘게 걸리는 일도 있었습니다.
+* 이를 막기 위해, oxlint가 돌아가고 있을 때에 새 runOxlint 호출이 들어오면 내부에서 알아서 잘 쟁여놨다가 실행 끝나면 배치로 굴립니다.
+* 한 번에 오직 하나의 oxlint cli 실행만 돌아가게 하는 겁니다.
+*
+* 자세한 배칭 전략:
+* - 아무 것도 없을 때에 호출되면 바로 oxlint 실행합니다.
+* - oxlint 실행 중에 들어오면 큐에 쟁여둡니다.
+* - oxlint 실행 완료 시점에서 큐에 뭐가 있으면 그걸로 다음 배치 바로 실행합니다.
+*
+* 그래서 띄엄띄엄 하나씩 들어오면 그냥 순차 실행과 다름이 없고, 여러개 우루루 들어오면 그때 효용이 생깁니다.
+* 다만 동시에 30개가 한번에 들어온다고 30개가 모두 한 배치를 타지는 않고,
+* idle에서의 첫 요청에 즉시 배치를 시작하므로 최소 2배치가 소요된다는 점 주의염.
+*/
+async function runOxlint(code) {
+	if (isTest()) return code;
+	const tmpFile = join(process.cwd(), `.sonamu-oxlint-${Date.now()}-${Math.random().toString(36).slice(2)}.ts`);
+	try {
+		await writeFile(tmpFile, code, "utf-8");
+		await enqueueOxlint(tmpFile);
+		return await readFile(tmpFile, "utf-8");
+	} finally {
+		try {
+			await unlink(tmpFile);
+		} catch {}
+	}
+}
+function enqueueOxlint(tmpFile) {
+	return new Promise((resolve, reject) => {
+		oxlintQueue.push({
+			tmpFile,
+			resolve,
+			reject
+		});
+		if (!isOxlintRunning) flushOxlintQueue();
+	});
+}
+async function flushOxlintQueue() {
+	if (isOxlintRunning || oxlintQueue.length === 0) return;
+	isOxlintRunning = true;
+	const batch = oxlintQueue.splice(0);
+	try {
+		try {
+			await execute(await resolveOxlintBin(), [
+				"--fix",
+				"--fix-suggestions",
+				"--type-aware",
+				...batch.map(({ tmpFile }) => tmpFile)
+			], { timeout: 1e4 });
+		} catch (e) {
+			const error = e;
+			if (!isNumberValue(error.code)) {
+				batch.forEach(({ reject }) => reject(error));
+				return;
+			}
+		}
+		batch.forEach(({ resolve }) => resolve());
+	} finally {
+		isOxlintRunning = false;
+		if (oxlintQueue.length > 0) flushOxlintQueue();
+	}
+}
+async function resolveOxlintBin(options = {
+	resolveModule: (specifier) => requireFromHere.resolve(specifier),
+	readFile: (filePath) => readFile(filePath, "utf-8"),
+	access: (filePath, mode) => access(filePath, mode)
+}) {
+	let manifestPath;
+	try {
+		manifestPath = options.resolveModule("oxlint/package.json");
+	} catch {
+		throw createOxlintBinResolutionError("oxlint package.json을 찾을 수 없습니다. oxlint 의존성을 설치한 뒤 다시 시도해 주세요.");
+	}
+	let manifest;
+	try {
+		manifest = JSON.parse(await options.readFile(manifestPath));
+	} catch {
+		throw createOxlintBinResolutionError("oxlint package.json을 읽거나 해석할 수 없습니다. 패키지를 다시 설치한 뒤 시도해 주세요.");
+	}
+	const stringBinManifest = OxlintStringBinManifestSchema.safeParse(manifest);
+	const namedBinManifest = OxlintNamedBinManifestSchema.safeParse(manifest);
+	let bin = null;
+	if (stringBinManifest.success) bin = stringBinManifest.data.bin;
+	else if (namedBinManifest.success) bin = namedBinManifest.data.bin.oxlint;
+	if (bin === null) throw createOxlintBinResolutionError("oxlint package.json의 bin 필드가 없거나 올바르지 않습니다. 호환되는 oxlint 패키지를 설치해 주세요.");
+	const binPath = path.resolve(dirname(manifestPath), bin);
+	try {
+		await options.access(binPath, constants.F_OK | constants.X_OK);
+	} catch {
+		throw createOxlintBinResolutionError("oxlint package.json의 bin 실행 파일이 없거나 실행할 수 없습니다. 패키지를 다시 설치해 주세요.");
+	}
+	return binPath;
+}
+function createOxlintBinResolutionError(message) {
+	return Object.assign(new Error(message), { code: "OXLINT_BIN_RESOLUTION_FAILED" });
+}
+var requireFromHere, OxlintStringBinManifestSchema, OxlintNamedBinManifestSchema, oxlintQueue, isOxlintRunning;
+var init_oxlint = __esmMin((() => {
+	init_controller();
+	init_process_utils();
+	init_runtime_value();
+	requireFromHere = createRequire(import.meta.url);
+	OxlintStringBinManifestSchema = z.object({ bin: z.string().trim().min(1) });
+	OxlintNamedBinManifestSchema = z.object({ bin: z.object({ oxlint: z.string().trim().min(1) }) });
+	oxlintQueue = [];
+	isOxlintRunning = false;
+}));
+//#endregion
+init_oxlint();
+export { init_oxlint, resolveOxlintBin, runOxlint };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"oxlint.js","names":[],"sources":["../../src/code-formatting/oxlint.ts"],"sourcesContent":["// 테스트 환경에서는 fs/promises가 mock되지만, 아래 runOxlint이 isTest 가드로 안 도니까\n// 그냥 fs/promises 그대로 사용. (production에서만 임시파일 흐름이 돕니다.)\nimport { constants } from \"node:fs\";\nimport { access, readFile, unlink, writeFile } from \"node:fs/promises\";\nimport { createRequire } from \"node:module\";\nimport path, { dirname, join } from \"node:path\";\n\nimport { z } from \"zod\";\n\nimport { isTest } from \"../utils/controller\";\nimport { execute } from \"../utils/process-utils\";\nimport { isNumberValue } from \"../utils/runtime-value\";\n\nconst requireFromHere = createRequire(import.meta.url);\n\nexport type ResolveOxlintBinOptions = {\n  resolveModule: (specifier: string) => string;\n  readFile: (filePath: string) => Promise<string>;\n  access: (filePath: string, mode: number) => Promise<void>;\n};\n\nconst OxlintStringBinManifestSchema = z.object({ bin: z.string().trim().min(1) });\nconst OxlintNamedBinManifestSchema = z.object({\n  bin: z.object({ oxlint: z.string().trim().min(1) }),\n});\n\ntype OxlintRequest = {\n  tmpFile: string;\n  resolve: () => void;\n  reject: (error: OxlintError) => void;\n};\n\ntype OxlintError = Error & { code?: string | number | null };\n\nconst oxlintQueue: OxlintRequest[] = [];\nlet isOxlintRunning = false;\n\n/**\n * 프로젝트 설정에 맞춰 코드를 lint합니다.\n *\n * 프로젝트 설정을 적용받는 oxlint cli를 찾아 띄워서,\n * 임시 파일에 in-place로 써서 그 결과를 빼오는 방식으로 작동합니다.\n * 왜 이렇게 하느냐? oxlint가 node api도 안 주고 cli에서 stdin 옵션도 안 주기 때문...\n *\n * 그런데 이 친구는 호출할 때마다 무지성으로 oxlint cli를 돌리지는 않습니다.\n * 그런 식으로 했다가는 oxlint 프로세스만 동시에 수십 개가 떠 있게 될 수도 있어요.\n * 그러다가 sync에서 파일 생성이 10초도 넘게 걸리는 일도 있었습니다.\n * 이를 막기 위해, oxlint가 돌아가고 있을 때에 새 runOxlint 호출이 들어오면 내부에서 알아서 잘 쟁여놨다가 실행 끝나면 배치로 굴립니다.\n * 한 번에 오직 하나의 oxlint cli 실행만 돌아가게 하는 겁니다.\n *\n * 자세한 배칭 전략:\n * - 아무 것도 없을 때에 호출되면 바로 oxlint 실행합니다.\n * - oxlint 실행 중에 들어오면 큐에 쟁여둡니다.\n * - oxlint 실행 완료 시점에서 큐에 뭐가 있으면 그걸로 다음 배치 바로 실행합니다.\n *\n * 그래서 띄엄띄엄 하나씩 들어오면 그냥 순차 실행과 다름이 없고, 여러개 우루루 들어오면 그때 효용이 생깁니다.\n * 다만 동시에 30개가 한번에 들어온다고 30개가 모두 한 배치를 타지는 않고,\n * idle에서의 첫 요청에 즉시 배치를 시작하므로 최소 2배치가 소요된다는 점 주의염.\n */\nexport async function runOxlint(code: string): Promise<string> {\n  if (isTest()) {\n    // 테스트 환경에서는 느려지기만 하고 검증할 가치도 없어서 안 합니다.\n    // GitHub Actions 환경에서 lint가 오래 걸려서 뻗기도 했어요. (https://github.com/cartanova-ai/sonamu/actions/runs/25267214027/job/74083630169)\n    return code;\n  }\n\n  const tmpFile = join(\n    // 타겟 파일이 루트 아래에 있어야 해요. 그래서 tmp 디렉토리같은거 안 씁니다!\n    process.cwd(),\n    `.sonamu-oxlint-${Date.now()}-${Math.random().toString(36).slice(2)}.ts`,\n  );\n\n  try {\n    await writeFile(tmpFile, code, \"utf-8\");\n    await enqueueOxlint(tmpFile);\n    return await readFile(tmpFile, \"utf-8\");\n  } finally {\n    try {\n      await unlink(tmpFile);\n    } catch {\n      // 삭제 실패해도 어차피 ignore됨.\n    }\n  }\n}\n\nfunction enqueueOxlint(tmpFile: string): Promise<void> {\n  return new Promise((resolve, reject) => {\n    oxlintQueue.push({ tmpFile, resolve, reject });\n    if (!isOxlintRunning) {\n      void flushOxlintQueue();\n    }\n  });\n}\n\nasync function flushOxlintQueue(): Promise<void> {\n  if (isOxlintRunning || oxlintQueue.length === 0) {\n    return;\n  }\n\n  isOxlintRunning = true;\n  // 실행을 시작할 때까지 준비된 파일만 묶어 다음 요청은 후속 배치로 넘깁니다.\n  const batch = oxlintQueue.splice(0);\n\n  try {\n    try {\n      await execute(\n        await resolveOxlintBin(),\n        [\"--fix\", \"--fix-suggestions\", \"--type-aware\", ...batch.map(({ tmpFile }) => tmpFile)],\n        {\n          timeout: 10000,\n        },\n      );\n    } catch (e) {\n      // lint 위반 시 exit code != 0이지만 --fix는 적용됨. exec 자체 실패만 배치 전체에 전달합니다.\n      // SAFETY: 선행 분기와 함수 계약이 이 타입을 보장합니다.\n      const error = e as OxlintError;\n      if (!isNumberValue(error.code)) {\n        batch.forEach(({ reject }) => reject(error));\n        return;\n      }\n    }\n\n    batch.forEach(({ resolve }) => resolve());\n  } finally {\n    isOxlintRunning = false;\n    if (oxlintQueue.length > 0) {\n      void flushOxlintQueue();\n    }\n  }\n}\n\nexport async function resolveOxlintBin(\n  options: ResolveOxlintBinOptions = {\n    resolveModule: (specifier) => requireFromHere.resolve(specifier),\n    readFile: (filePath) => readFile(filePath, \"utf-8\"),\n    access: (filePath, mode) => access(filePath, mode),\n  },\n): Promise<string> {\n  let manifestPath: string;\n  try {\n    manifestPath = options.resolveModule(\"oxlint/package.json\");\n  } catch {\n    throw createOxlintBinResolutionError(\n      \"oxlint package.json을 찾을 수 없습니다. oxlint 의존성을 설치한 뒤 다시 시도해 주세요.\",\n    );\n  }\n\n  let manifest: unknown;\n  try {\n    manifest = JSON.parse(await options.readFile(manifestPath));\n  } catch {\n    throw createOxlintBinResolutionError(\n      \"oxlint package.json을 읽거나 해석할 수 없습니다. 패키지를 다시 설치한 뒤 시도해 주세요.\",\n    );\n  }\n\n  // npm의 bin은 단일 실행 파일 문자열과 명령 이름별 객체를 모두 허용합니다.\n  const stringBinManifest = OxlintStringBinManifestSchema.safeParse(manifest);\n  const namedBinManifest = OxlintNamedBinManifestSchema.safeParse(manifest);\n  let bin: string | null = null;\n  if (stringBinManifest.success) {\n    bin = stringBinManifest.data.bin;\n  } else if (namedBinManifest.success) {\n    bin = namedBinManifest.data.bin.oxlint;\n  }\n  if (bin === null) {\n    throw createOxlintBinResolutionError(\n      \"oxlint package.json의 bin 필드가 없거나 올바르지 않습니다. 호환되는 oxlint 패키지를 설치해 주세요.\",\n    );\n  }\n\n  const binPath = path.resolve(dirname(manifestPath), bin);\n  try {\n    await options.access(binPath, constants.F_OK | constants.X_OK);\n  } catch {\n    throw createOxlintBinResolutionError(\n      \"oxlint package.json의 bin 실행 파일이 없거나 실행할 수 없습니다. 패키지를 다시 설치해 주세요.\",\n    );\n  }\n\n  return binPath;\n}\nfunction createOxlintBinResolutionError(message: string): NodeJS.ErrnoException {\n  return Object.assign(new Error(message), { code: \"OXLINT_BIN_RESOLUTION_FAILED\" });\n}\n"],"mappings":"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"}

package/dist/cone/cone-generator.js

@@ -1,8 +1,8 @@
 import { __esmMin, __toCommonJS } from "../_virtual/_rolldown/runtime.js";
 import { init_runtime_value, isObjectValue } from "../utils/runtime-value.js";
 import { api_exports, init_api } from "../api/index.js";
-import * as fs$1 from "node:fs";
 import * as path$1 from "node:path";
+import * as fs$1 from "node:fs";
 //#region src/cone/cone-generator.ts
 /**
 * LLM을 사용하여 Entity의 cone 메타데이터를 생성합니다.