sonamu 0.10.13 → 0.11.0

package/src/tooling/fixture-service.ts

@@ -0,0 +1,72 @@
+import { z } from "zod";
+
+const legacyFixtureOptionsSchema = z.object({
+  _: z.array(z.string()).optional(),
+  all: z.boolean().optional(),
+  include: z.string().optional(),
+  exclude: z.string().optional(),
+  count: z.union([z.string(), z.number()]).optional(),
+  strategy: z.string().optional(),
+  limit: z.union([z.string(), z.number()]).optional(),
+  saveTo: z.string().optional(),
+  useLlm: z.boolean().optional(),
+  noCache: z.boolean().optional(),
+  "save-to": z.string().optional(),
+  "use-llm": z.boolean().optional(),
+  "no-cache": z.boolean().optional(),
+  nonInteractive: z.boolean().optional(),
+  userMode: z.enum(["login", "dummy"]).optional(),
+});
+
+type LegacyFixtureOptions = z.infer<typeof legacyFixtureOptionsSchema>;
+export type LegacyFixtureSource = z.input<typeof legacyFixtureOptionsSchema>;
+export type LegacyFixtureCommand = "gen" | "fetch" | "explore";
+export type NormalizedLegacyFixtureOptions = Omit<
+  LegacyFixtureOptions,
+  "saveTo" | "useLlm" | "noCache"
+>;
+
+export function normalizeLegacyFixtureOptions(
+  input: LegacyFixtureSource,
+): NormalizedLegacyFixtureOptions {
+  const { saveTo, useLlm, noCache, ...options } = legacyFixtureOptionsSchema.parse(input);
+  return {
+    ...options,
+    "save-to": saveTo ?? options["save-to"],
+    "use-llm": useLlm ?? options["use-llm"],
+    "no-cache": noCache ?? options["no-cache"],
+  };
+}
+
+function hasLegacyFixtureSelector(
+  command: LegacyFixtureCommand,
+  input: NormalizedLegacyFixtureOptions,
+): boolean {
+  const hasInclude = input.include !== undefined && input.include.trim().length > 0;
+  return command === "explore" ? hasInclude : input.all === true || hasInclude;
+}
+
+export function normalizeLegacyFixtureCommandOptions(
+  command: LegacyFixtureCommand,
+  input: LegacyFixtureSource,
+): NormalizedLegacyFixtureOptions {
+  const normalized = normalizeLegacyFixtureOptions(input);
+  if (normalized.nonInteractive !== true) return normalized;
+
+  if (!hasLegacyFixtureSelector(command, normalized)) {
+    throw Object.assign(new Error(`Missing fixture ${command} selector.`), {
+      code: "MISSING_ARGUMENT",
+      exitCode: 2,
+    });
+  }
+
+  if (command !== "gen") return normalized;
+  return {
+    ...normalized,
+    count: normalized.count || 5,
+    "save-to": normalized["save-to"] || "db",
+    "use-llm": normalized["use-llm"] ?? false,
+    "no-cache": normalized["no-cache"] ?? false,
+    userMode: normalized.userMode ?? "dummy",
+  };
+}

package/src/tooling/index.ts

@@ -0,0 +1 @@
+export { tooling } from "./cli-tooling";

package/src/tooling/test-run-client.ts

@@ -0,0 +1,196 @@
+import { z } from "zod";
+
+import { loadConfig } from "../api/config";
+import { findApiRootPath } from "../utils/utils";
+
+export interface TestRunRequest {
+  files?: string[];
+  pattern?: string;
+  traces?: boolean;
+}
+
+interface TestRunResult {
+  ok: boolean;
+  summary: {
+    total: number;
+    passed: number;
+    failed: number;
+    skipped: number;
+    durationMs: number;
+  };
+  results: z.infer<typeof jsonValueSchema>[];
+}
+
+export interface TestRunClient {
+  status(): Promise<JsonObject>;
+  run(input: TestRunRequest): Promise<TestRunResult>;
+}
+
+interface TestRunClientDependencies {
+  projectRoot: string;
+  loadConfig(projectRoot: string): Promise<object>;
+  fetch: typeof globalThis.fetch;
+}
+
+class TestRunClientError extends Error {
+  constructor(
+    readonly code:
+      | "TEST_RUN_CONFIG_ERROR"
+      | "TEST_RUN_FAILED"
+      | "TEST_RUN_HTTP_ERROR"
+      | "TEST_RUN_NETWORK_ERROR",
+    message: string,
+  ) {
+    super(message);
+    this.name = "TestRunClientError";
+  }
+}
+
+const jsonValueSchema = z.json();
+const jsonObjectSchema = z.record(z.string(), jsonValueSchema);
+type JsonObject = z.infer<typeof jsonObjectSchema>;
+const configSchema = z.object({
+  server: z
+    .object({
+      listen: z.object({ host: z.string().optional(), port: z.number().optional() }).optional(),
+    })
+    .optional(),
+  test: z
+    .object({
+      devRunner: z
+        .object({ enabled: z.boolean().optional(), routePrefix: z.string().optional() })
+        .optional(),
+    })
+    .optional(),
+});
+const testRunResultSchema = z.object({
+  ok: z.boolean(),
+  summary: z.object({
+    total: z.number(),
+    passed: z.number(),
+    failed: z.number(),
+    skipped: z.number(),
+    durationMs: z.number(),
+  }),
+  results: z.array(jsonValueSchema),
+});
+
+/**
+ * sonamu.config를 소스(`src/sonamu.config.ts`)에서 읽도록 강제해 설정을 불러옵니다.
+ *
+ * loadConfig는 VITEST/HOT 환경변수로 dist/소스 설정을 고르므로, dist 빌드가 없는
+ * 일반 개발 셸에서도 소스 설정을 읽도록 VITEST를 잠시 켜고 원래 값을 그대로 복원합니다.
+ */
+async function loadSourceConfig(dependencies: TestRunClientDependencies): Promise<object> {
+  const previousVitest = process.env.VITEST;
+  process.env.VITEST = "true";
+  try {
+    return await dependencies.loadConfig(dependencies.projectRoot);
+  } finally {
+    if (previousVitest === undefined) {
+      delete process.env.VITEST;
+    } else {
+      process.env.VITEST = previousVitest;
+    }
+  }
+}
+
+async function resolveBaseUrl(dependencies: TestRunClientDependencies): Promise<string> {
+  let config: object;
+  try {
+    config = await loadSourceConfig(dependencies);
+  } catch {
+    throw new TestRunClientError(
+      "TEST_RUN_CONFIG_ERROR",
+      "sonamu.config를 불러올 수 없습니다. 프로젝트 설정을 확인하세요.",
+    );
+  }
+  const parsedConfig = configSchema.parse(config);
+  const listen = parsedConfig.server?.listen;
+  const devRunner = parsedConfig.test?.devRunner;
+  if (devRunner?.enabled !== true) {
+    throw new TestRunClientError(
+      "TEST_RUN_CONFIG_ERROR",
+      "sonamu.config의 test.devRunner.enabled를 true로 설정해야 합니다.",
+    );
+  }
+  const configuredHost = listen?.host ?? "localhost";
+  const host = ["0.0.0.0", "::"].includes(configuredHost) ? "127.0.0.1" : configuredHost;
+  const port = listen?.port ?? 3000;
+  const routePrefix = devRunner.routePrefix ?? "/__test__";
+  const prefix = (routePrefix.startsWith("/") ? routePrefix : `/${routePrefix}`).replace(/\/$/, "");
+  return `http://${host}:${port}${prefix}`;
+}
+
+async function requestJson(
+  dependencies: TestRunClientDependencies,
+  url: string,
+  init?: RequestInit,
+): Promise<JsonObject> {
+  let response: Response;
+  try {
+    response = await dependencies.fetch(url, init);
+  } catch {
+    throw new TestRunClientError(
+      "TEST_RUN_NETWORK_ERROR",
+      "로컬 DevRunner에 연결할 수 없습니다. sonamu dev 실행 상태를 확인하세요.",
+    );
+  }
+  if (!response.ok) {
+    throw new TestRunClientError(
+      "TEST_RUN_HTTP_ERROR",
+      `DevRunner 요청이 HTTP ${response.status} 상태로 실패했습니다.`,
+    );
+  }
+  const object = jsonObjectSchema.safeParse(await response.json());
+  if (!object.success) {
+    throw new TestRunClientError("TEST_RUN_HTTP_ERROR", "DevRunner 응답이 JSON 객체가 아닙니다.");
+  }
+  return object.data;
+}
+
+function parseResult(value: JsonObject): TestRunResult {
+  const result = testRunResultSchema.safeParse(value);
+  if (!result.success) {
+    throw new TestRunClientError(
+      "TEST_RUN_HTTP_ERROR",
+      "DevRunner 테스트 결과의 구조가 올바르지 않습니다.",
+    );
+  }
+  return result.data;
+}
+
+function createTestRunClient(dependencies: TestRunClientDependencies): TestRunClient {
+  return {
+    async status() {
+      return requestJson(dependencies, `${await resolveBaseUrl(dependencies)}/status`);
+    },
+    async run(input) {
+      const payload: TestRunRequest = {};
+      if (input.files !== undefined) payload.files = input.files;
+      if (input.pattern !== undefined) payload.pattern = input.pattern;
+      const result = parseResult(
+        await requestJson(dependencies, `${await resolveBaseUrl(dependencies)}/run`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify(payload),
+        }),
+      );
+      if (!result.ok) {
+        throw Object.assign(
+          new TestRunClientError("TEST_RUN_FAILED", "테스트 실행이 실패했습니다."),
+          { exitCode: 1, result },
+        );
+      }
+      return result;
+    },
+  };
+}
+
+export function createDefaultTestRunClient(projectRoot: string = findApiRootPath()): TestRunClient {
+  return createTestRunClient({
+    projectRoot,
+    loadConfig,
+    fetch: globalThis.fetch,
+  });
+}

package/src/utils/__tests__/formatter-bin.test.ts

@@ -0,0 +1,99 @@
+import { constants } from "node:fs";
+import { access, mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+import { createRequire } from "node:module";
+import os from "node:os";
+import path from "node:path";
+
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { z } from "zod";
+
+import { resolveOxlintBin } from "../formatter";
+
+const OxlintManifestSchema = z
+  .union([
+    z.object({ bin: z.string().min(1) }),
+    z.object({ bin: z.object({ oxlint: z.string().min(1) }) }).transform(({ bin }) => ({
+      bin: bin.oxlint,
+    })),
+  ])
+  .transform(({ bin }) => ({ bin }));
+
+type ResolveOxlintBinOptions = {
+  resolveModule: (specifier: string) => string;
+  readFile: (filePath: string) => Promise<string>;
+  access: (filePath: string, mode: number) => Promise<void>;
+};
+
+const tempRoots: string[] = [];
+
+async function createTempRoot() {
+  const root = await mkdtemp(path.join(os.tmpdir(), "sonamu-oxlint-manifest-"));
+  tempRoots.push(root);
+  return root;
+}
+
+afterEach(async () => {
+  vi.restoreAllMocks();
+  await Promise.all(tempRoots.splice(0).map((root) => rm(root, { recursive: true, force: true })));
+});
+
+describe("oxlint 실행 파일 해석 회귀", () => {
+  it("설치된 패키지 manifest에서 실행 가능한 로컬 절대 경로를 반환한다", async () => {
+    const requireFromFormatter = createRequire(new URL("../formatter.ts", import.meta.url));
+    const manifestPath = requireFromFormatter.resolve("oxlint/package.json");
+    const manifest = OxlintManifestSchema.parse(JSON.parse(await readFile(manifestPath, "utf8")));
+    const expectedBin = path.resolve(path.dirname(manifestPath), manifest.bin);
+    const options: ResolveOxlintBinOptions = {
+      resolveModule: (specifier) => requireFromFormatter.resolve(specifier),
+      readFile: (filePath) => readFile(filePath, "utf8"),
+      access,
+    };
+
+    const resolvedBin = await resolveOxlintBin(options);
+
+    expect(resolvedBin).toBe(expectedBin);
+    expect(path.isAbsolute(resolvedBin)).toBe(true);
+    await expect(access(resolvedBin, constants.F_OK | constants.X_OK)).resolves.toBeUndefined();
+  });
+
+  it.each([
+    ["manifest 파일이 없음", null],
+    ["manifest JSON이 잘못됨", "{ invalid json"],
+    ["manifest에 bin 필드가 없음", JSON.stringify({ name: "oxlint" })],
+  ])("임시 패키지의 %s이면 해결 방법이 있는 오류를 반환한다", async (_caseName, manifest) => {
+    const packageRoot = await createTempRoot();
+    const manifestPath = path.join(packageRoot, "package.json");
+    if (manifest !== null) await writeFile(manifestPath, manifest);
+    const options: ResolveOxlintBinOptions = {
+      resolveModule: vi.fn(() => manifestPath),
+      readFile: vi.fn((filePath) => readFile(filePath, "utf8")),
+      access: vi.fn(access),
+    };
+
+    await expect(resolveOxlintBin(options)).rejects.toMatchObject({
+      code: "OXLINT_BIN_RESOLUTION_FAILED",
+      message: expect.stringMatching(/oxlint.*(?:package\.json|bin)/i),
+    });
+    expect(options.resolveModule).toHaveBeenCalledWith("oxlint/package.json");
+    expect(options.readFile).toHaveBeenCalledWith(manifestPath);
+    expect(options.access).not.toHaveBeenCalled();
+  });
+
+  it("manifest가 가리키는 실행 파일이 없으면 실행 가능 여부를 검사하고 오류를 반환한다", async () => {
+    const packageRoot = await createTempRoot();
+    const manifestPath = path.join(packageRoot, "package.json");
+    const missingBinPath = path.join(packageRoot, "bin", "oxlint");
+    await writeFile(manifestPath, JSON.stringify({ bin: { oxlint: "bin/oxlint" } }));
+    const options: ResolveOxlintBinOptions = {
+      resolveModule: vi.fn(() => manifestPath),
+      readFile: vi.fn((filePath) => readFile(filePath, "utf8")),
+      access: vi.fn(access),
+    };
+
+    await expect(resolveOxlintBin(options)).rejects.toMatchObject({
+      code: "OXLINT_BIN_RESOLUTION_FAILED",
+      message: expect.stringMatching(/실행 파일.*없거나 실행할 수 없습니다/),
+    });
+    expect(options.access).toHaveBeenCalledWith(missingBinPath, constants.F_OK | constants.X_OK);
+  });
+});

package/src/utils/formatter.ts

@@ -1,11 +1,13 @@
-import { createHash } from "crypto";
+import { createHash } from "node:crypto";
 // 테스트 환경에서는 fs/promises가 mock되지만, 아래 runOxlint이 isTest 가드로 안 도니까
 // 그냥 fs/promises 그대로 사용. (production에서만 임시파일 흐름이 돕니다.)
-import { readFile, unlink, writeFile } from "fs/promises";
-import { createRequire } from "module";
-import path, { dirname, join } from "path";
+import { constants } from "node:fs";
+import { access, readFile, unlink, writeFile } from "node:fs/promises";
+import { createRequire } from "node:module";
+import path, { dirname, join } from "node:path";
 
 import { format, type FormatConfig } from "oxfmt";
+import { z } from "zod";
 
 import { cached } from "./async-utils";
 import { isTest } from "./controller";
@@ -14,6 +16,17 @@ import { isNumberValue } from "./runtime-value";
 
 const requireFromHere = createRequire(import.meta.url);
 
+export type ResolveOxlintBinOptions = {
+  resolveModule: (specifier: string) => string;
+  readFile: (filePath: string) => Promise<string>;
+  access: (filePath: string, mode: number) => Promise<void>;
+};
+
+const OxlintStringBinManifestSchema = z.object({ bin: z.string().trim().min(1) });
+const OxlintNamedBinManifestSchema = z.object({
+  bin: z.object({ oxlint: z.string().trim().min(1) }),
+});
+
 /**
  * 코드를 프로젝트의 oxfmt + oxlint 설정에 맞춰 포매팅한 문자열을 반환합니다.
  *
@@ -119,9 +132,13 @@ async function runOxlint(code: string): Promise<string> {
     await writeFile(tmpFile, code, "utf-8");
 
     try {
-      await execute(resolveOxlintBin(), ["--fix", "--fix-suggestions", "--type-aware", tmpFile], {
-        timeout: 10000,
-      });
+      await execute(
+        await resolveOxlintBin(),
+        ["--fix", "--fix-suggestions", "--type-aware", tmpFile],
+        {
+          timeout: 10000,
+        },
+      );
     } catch (e) {
       // lint 위반 시 exit code != 0이지만 --fix는 적용됨. exec 자체 실패만 throw.
       // SAFETY: 선행 분기와 함수 계약이 이 타입을 보장합니다.
@@ -140,10 +157,57 @@ async function runOxlint(code: string): Promise<string> {
   }
 }
 
-function resolveOxlintBin(): string {
+export async function resolveOxlintBin(
+  options: ResolveOxlintBinOptions = {
+    resolveModule: (specifier) => requireFromHere.resolve(specifier),
+    readFile: (filePath) => readFile(filePath, "utf-8"),
+    access: (filePath, mode) => access(filePath, mode),
+  },
+): Promise<string> {
+  let manifestPath: string;
+  try {
+    manifestPath = options.resolveModule("oxlint/package.json");
+  } catch {
+    throw createOxlintBinResolutionError(
+      "oxlint package.json을 찾을 수 없습니다. oxlint 의존성을 설치한 뒤 다시 시도해 주세요.",
+    );
+  }
+
+  let manifest: unknown;
+  try {
+    manifest = JSON.parse(await options.readFile(manifestPath));
+  } catch {
+    throw createOxlintBinResolutionError(
+      "oxlint package.json을 읽거나 해석할 수 없습니다. 패키지를 다시 설치한 뒤 시도해 주세요.",
+    );
+  }
+
+  // npm의 bin은 단일 실행 파일 문자열과 명령 이름별 객체를 모두 허용합니다.
+  const stringBinManifest = OxlintStringBinManifestSchema.safeParse(manifest);
+  const namedBinManifest = OxlintNamedBinManifestSchema.safeParse(manifest);
+  let bin: string | null = 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 {
-    return requireFromHere.resolve("oxlint/bin/oxlint");
+    await options.access(binPath, constants.F_OK | constants.X_OK);
   } catch {
-    return "oxlint";
+    throw createOxlintBinResolutionError(
+      "oxlint package.json의 bin 실행 파일이 없거나 실행할 수 없습니다. 패키지를 다시 설치해 주세요.",
+    );
   }
+
+  return binPath;
+}
+function createOxlintBinResolutionError(message: string): NodeJS.ErrnoException {
+  return Object.assign(new Error(message), { code: "OXLINT_BIN_RESOLUTION_FAILED" });
 }

package/tsdown.api.config.ts

@@ -1,8 +1,6 @@
-import { readdirSync, statSync } from "node:fs";
+import { readdir, stat } from "node:fs/promises";
 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"]);
@@ -10,19 +8,19 @@ interface BuildEntries {
   [entryName: string]: string;
 }
 
-function collectEntries(directory: string): BuildEntries {
+async function collectEntries(directory: string): Promise<BuildEntries> {
   const entries: BuildEntries = {};
 
-  for (const entry of readdirSync(directory)) {
+  for (const entry of await readdir(directory)) {
     if (ignoredDirectories.has(entry)) {
       continue;
     }
 
     const absolutePath = path.join(directory, entry);
-    const stats = statSync(absolutePath);
+    const stats = await stat(absolutePath);
 
     if (stats.isDirectory()) {
-      Object.assign(entries, collectEntries(absolutePath));
+      Object.assign(entries, await collectEntries(absolutePath));
       continue;
     }
 
@@ -41,13 +39,13 @@ function collectEntries(directory: string): BuildEntries {
   return entries;
 }
 
-export default defineConfig({
+export default {
   clean: true,
   deps: {
     neverBundle: [/^sonamu(?:\/.*)?$/],
   },
   dts: false,
-  entry: collectEntries(srcRoot),
+  entry: await collectEntries(srcRoot),
   fixedExtension: false,
   format: "esm",
   outDir: path.resolve(process.cwd(), "dist"),
@@ -56,4 +54,4 @@ export default defineConfig({
   target: "esnext",
   treeshake: false,
   unbundle: true,
-});
+};

package/bin/cli.js

@@ -1,75 +0,0 @@
-#!/usr/bin/env node
-
-import { spawn } from "child_process";
-import { createRequire } from "module";
-import { fileURLToPath } from "url";
-
-const require = createRequire(import.meta.url);
-const sourceCliPath = fileURLToPath(new URL("../src/bin/cli.ts", import.meta.url));
-const tsxImportPath = (() => {
-  try {
-    return require.resolve("tsx");
-  } catch {
-    return "tsx";
-  }
-})();
-
-function printCliError(error, fallbackError) {
-  console.error(
-    "Sonamu CLI를 실행하는 과정에 문제가 발생하였습니다. 보통은 dist/bin/cli.js 파일이 없는 경우입니다만, 아래 에러 메시지를 자세히 읽어보시면 힌트를 얻으실 수 있을 것입니다.",
-  );
-  console.error(
-    "There was an error while executing Sonamu CLI. Usually it's because dist/bin/cli.js file is not found. Please read the error message below for more information.",
-  );
-  console.error("=".repeat(80));
-  console.error(error);
-
-  if (fallbackError) {
-    console.error("-".repeat(80));
-    console.error("Source CLI fallback also failed.");
-    console.error(fallbackError);
-  }
-}
-
-function runSourceCli(originalError) {
-  const child = spawn(
-    process.execPath,
-    ["--import", tsxImportPath, sourceCliPath, ...process.argv.slice(2)],
-    {
-      env: process.env,
-      stdio: "inherit",
-    },
-  );
-
-  child.on("error", (fallbackError) => {
-    printCliError(originalError, fallbackError);
-    process.exit(1);
-  });
-
-  child.on("exit", (code) => {
-    if ((code ?? 1) !== 0) {
-      printCliError(originalError);
-    }
-    process.exit(code ?? 1);
-  });
-}
-
-/**
- * 이 스크립트는 터미널 또는 기타 환경에서 pnpm sonamu 또는 sonamu 명령어를 호출하였을 때 실행되는 스크립트입니다.
- *
- * sonamu 패키지 package.json의 bin 필드는 dist/bin/cli.js를 직접 가리키지 않습니다. 대신 이 스크립트를 가리킵니다.
- * 이는 개발 환경(TypeScript + pnpm workspace + clone 받으면 dist가 없음)에서 발생할 수 있는 문제를 해결하기 위함입니다.
- *
- * pnpm은 패키지 설치 시점에 bin 필드가 가리키는 파일이 존재하기를 요구합니다.
- * 가령 bin에 dist/bin/cli.js가 명시되어 있다면, sonamu를 install 하는 시점에 해당 파일을 pnpm이 찾아서 읽습니다.
- * 그런데 install 시점에 sonamu의 src는 있어도 dist는 없는 상황이 발생할 수 있습니다(주로 새로 clone 받아서 작업할 때).
- * 이 경우에는 pnpm이 install 시점에 해당 bin(=dist/bin/cli.js)을 처리하지 못 하여 sonamu 명령을 사용할 수 없는 상태가 됩니다.
- * 이렇게 된다면 sonamu를 빌드한 후에 다시 install을 해야 하는 불편함이 발생합니다.
- *
- * 이를 해결하기 위해 dist 존재 유무와 무관하게 **항상** 존재하는 이 wrapper 스크립트를 추가하였습니다.
- * pnpm이 실행하는 실제 스크립트는 이 스크립트이며, 이 스크립트는 dist/bin/cli.js를 동적으로 찾아서 실행(eval)해줍니다.
- * 만약 sonamu가 아직 빌드되지 않은 상태에서 sonamu 명령을 사용하려 하면 아래와 같이 console.error를 출력하고 process.exit(1)을 호출합니다.
- *
- * 이 스크립트를 실행시킬 때 넘어온 인자와 환경변수 등은 모두 dist/bin/cli.js에 그대로 전달됩니다.
- */
-import("../dist/bin/cli.js").catch(runSourceCli);

package/dist/bin/cli.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=cli.d.ts.map

package/dist/bin/cli.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../../src/bin/cli.ts"],"names":[],"mappings":""}