@simplysm/sd-cli 13.0.0-beta.46 → 13.0.0-beta.47

package/src/commands/device.ts

@@ -0,0 +1,151 @@
+import path from "path";
+import { Listr } from "listr2";
+import { fsExists } from "@simplysm/core-node";
+import { consola } from "consola";
+import type { SdConfig, SdClientPackageConfig } from "../sd-config.types";
+import { loadSdConfig } from "../utils/sd-config";
+import { Capacitor } from "../capacitor/capacitor";
+import { Electron } from "../electron/electron";
+
+//#region Types
+
+/**
+ * Device 명령 옵션
+ */
+export interface DeviceOptions {
+  /** 패키지 이름 (필수) */
+  package: string;
+  /** 개발 서버 URL (선택, 미지정 시 sd.config.ts의 server 설정 사용) */
+  url?: string;
+  /** sd.config.ts에 전달할 추가 옵션 */
+  options: string[];
+}
+
+//#endregion
+
+//#region Main
+
+/**
+ * Android 디바이스에서 앱을 실행한다.
+ *
+ * - 연결된 Android 디바이스에서 앱 실행
+ * - 개발 서버 URL을 WebView에 연결하여 Hot Reload 지원
+ *
+ * @param options - device 실행 옵션
+ * @returns 완료 시 resolve
+ */
+export async function runDevice(options: DeviceOptions): Promise<void> {
+  const { package: packageName, url } = options;
+  const cwd = process.cwd();
+  const logger = consola.withTag("sd:cli:device");
+
+  logger.debug("device 시작", { package: packageName, url });
+
+  // sd.config.ts 로드
+  let sdConfig: SdConfig;
+  try {
+    sdConfig = await loadSdConfig({ cwd, dev: true, opt: options.options });
+    logger.debug("sd.config.ts 로드 완료");
+  } catch (err) {
+    consola.error(`sd.config.ts 로드 실패: ${err instanceof Error ? err.message : err}`);
+    process.exitCode = 1;
+    return;
+  }
+
+  // 패키지 설정 확인
+  const pkgConfig = sdConfig.packages[packageName];
+  if (pkgConfig == null) {
+    consola.error(`패키지를 찾을 수 없습니다: ${packageName}`);
+    process.exitCode = 1;
+    return;
+  }
+
+  if (pkgConfig.target !== "client") {
+    consola.error(`client 타겟 패키지만 지원합니다: ${packageName} (현재: ${pkgConfig.target})`);
+    process.exitCode = 1;
+    return;
+  }
+
+  const clientConfig: SdClientPackageConfig = pkgConfig;
+  const pkgDir = path.join(cwd, "packages", packageName);
+
+  if (clientConfig.electron != null) {
+    // Electron 개발 실행
+    let serverUrl = url;
+    if (serverUrl == null) {
+      if (typeof clientConfig.server === "number") {
+        serverUrl = `http://localhost:${clientConfig.server}/${packageName}/`;
+      } else {
+        consola.error(`--url 옵션이 필요합니다. server가 패키지명으로 설정되어 있습니다: ${clientConfig.server}`);
+        process.exitCode = 1;
+        return;
+      }
+    }
+
+    logger.debug("개발 서버 URL", { serverUrl });
+
+    const listr = new Listr([
+      {
+        title: `${packageName} (electron)`,
+        task: async () => {
+          const electron = await Electron.create(pkgDir, clientConfig.electron!);
+          await electron.run(serverUrl);
+        },
+      },
+    ]);
+
+    try {
+      await listr.run();
+      logger.info("Electron 실행 완료");
+    } catch (err) {
+      consola.error(`Electron 실행 실패: ${err instanceof Error ? err.message : err}`);
+      process.exitCode = 1;
+    }
+  } else if (clientConfig.capacitor != null) {
+    // Capacitor 디바이스 실행 (기존 로직)
+    let serverUrl = url;
+    if (serverUrl == null) {
+      if (typeof clientConfig.server === "number") {
+        serverUrl = `http://localhost:${clientConfig.server}/${packageName}/capacitor/`;
+      } else {
+        consola.error(`--url 옵션이 필요합니다. server가 패키지명으로 설정되어 있습니다: ${clientConfig.server}`);
+        process.exitCode = 1;
+        return;
+      }
+    } else if (!serverUrl.endsWith("/")) {
+      serverUrl = `${serverUrl}/${packageName}/capacitor/`;
+    }
+
+    logger.debug("개발 서버 URL", { serverUrl });
+
+    const capPath = path.join(pkgDir, ".capacitor");
+    if (!(await fsExists(capPath))) {
+      consola.error(`Capacitor 프로젝트가 초기화되지 않았습니다. 먼저 'pnpm watch ${packageName}'를 실행하세요.`);
+      process.exitCode = 1;
+      return;
+    }
+
+    const listr = new Listr([
+      {
+        title: `${packageName} (device)`,
+        task: async () => {
+          const cap = await Capacitor.create(pkgDir, clientConfig.capacitor!);
+          await cap.runOnDevice(serverUrl);
+        },
+      },
+    ]);
+
+    try {
+      await listr.run();
+      logger.info("디바이스 실행 완료");
+    } catch (err) {
+      consola.error(`디바이스 실행 실패: ${err instanceof Error ? err.message : err}`);
+      process.exitCode = 1;
+    }
+  } else {
+    consola.error(`electron 또는 capacitor 설정이 없습니다: ${packageName}`);
+    process.exitCode = 1;
+  }
+}
+
+//#endregion

package/src/commands/init.ts

@@ -0,0 +1,104 @@
+import path from "path";
+import fs from "fs";
+import { consola } from "consola";
+import { renderTemplateDir } from "../utils/template";
+import { spawn } from "../utils/spawn";
+
+//#region Types
+
+/**
+ * Init 명령 옵션
+ */
+export interface InitOptions {}
+
+//#endregion
+
+//#region Utilities
+
+/**
+ * import.meta.dirname에서 상위로 올라가며 package.json을 찾아 패키지 루트를 반환한다.
+ */
+function findPackageRoot(startDir: string): string {
+  let dir = startDir;
+  while (!fs.existsSync(path.join(dir, "package.json"))) {
+    const parent = path.dirname(dir);
+    if (parent === dir) throw new Error("package.json을 찾을 수 없습니다.");
+    dir = parent;
+  }
+  return dir;
+}
+
+/**
+ * npm 스코프 이름 유효성 검증
+ */
+function isValidScopeName(name: string): boolean {
+  return /^[a-z][a-z0-9-]*$/.test(name);
+}
+
+//#endregion
+
+//#region Main
+
+/**
+ * 새 Simplysm 프로젝트를 현재 디렉토리에 초기화한다.
+ *
+ * 1. 디렉토리 비어있는지 확인
+ * 2. 프로젝트명(폴더명) 검증
+ * 3. Handlebars 템플릿 렌더링
+ * 4. pnpm install 실행
+ */
+export async function runInit(_options: InitOptions): Promise<void> {
+  const cwd = process.cwd();
+  const logger = consola.withTag("sd:cli:init");
+
+  // 1. 디렉토리 비어있는지 확인 (dotfile/dotfolder 제외)
+  const entries = fs.readdirSync(cwd).filter((e) => !e.startsWith("."));
+  if (entries.length > 0) {
+    consola.error("디렉토리가 비어있지 않습니다. 빈 디렉토리에서 실행해주세요.");
+    process.exitCode = 1;
+    return;
+  }
+
+  // 2. 프로젝트명 검증
+  const projectName = path.basename(cwd);
+  if (!isValidScopeName(projectName)) {
+    consola.error(`프로젝트 이름 "${projectName}"이(가) 유효하지 않습니다. 소문자, 숫자, 하이픈만 사용 가능합니다.`);
+    process.exitCode = 1;
+    return;
+  }
+
+  // 3. 템플릿 렌더링
+  const pkgRoot = findPackageRoot(import.meta.dirname);
+  const templateDir = path.join(pkgRoot, "templates", "init");
+
+  const context = { projectName };
+
+  logger.info("프로젝트 파일 생성 중...");
+  await renderTemplateDir(templateDir, cwd, context);
+  logger.success("프로젝트 파일 생성 완료");
+
+  // 4. pnpm install
+  logger.info("pnpm install 실행 중...");
+  await spawn("pnpm", ["install"], { cwd });
+  logger.success("pnpm install 완료");
+
+  // 5. git 초기화
+  logger.info("git 저장소 초기화 중...");
+  await spawn("git", ["init"], { cwd });
+  await spawn("git", ["add", "."], { cwd });
+  await spawn("git", ["commit", "-m", "init"], { cwd });
+  logger.success("git 저장소 초기화 완료");
+
+  // 6. 완료 메시지
+  consola.box(
+    [
+      "프로젝트가 생성되었습니다!",
+      "",
+      "다음 단계:",
+      "  sd-cli add client    클라이언트 패키지 추가",
+      "  sd-cli add server    서버 패키지 추가",
+    ].join("\n"),
+  );
+}
+
+//#endregion

package/src/commands/lint.ts

@@ -0,0 +1,216 @@
+import { ESLint } from "eslint";
+import { createJiti } from "jiti";
+import path from "path";
+import { Listr } from "listr2";
+import { fsExists, fsGlob, pathFilterByTargets } from "@simplysm/core-node";
+import "@simplysm/core-common";
+import { SdError } from "@simplysm/core-common";
+import { consola, LogLevels } from "consola";
+
+//#region Types
+
+/**
+ * ESLint 실행 옵션
+ */
+export interface LintOptions {
+  /** 린트할 경로 필터 (예: `packages/core-common`). 빈 배열이면 전체 대상 */
+  targets: string[];
+  /** 자동 수정 활성화 */
+  fix: boolean;
+  /** ESLint 규칙별 실행 시간 측정 활성화 (TIMING 환경변수 설정) */
+  timing: boolean;
+}
+
+/**
+ * Listr2 컨텍스트 타입
+ */
+interface LintContext {
+  ignorePatterns: string[];
+  /** 파일 수집 태스크 완료 후 초기화됨 */
+  files?: string[];
+  /** 린트 대상 파일이 있을 때만 초기화됨 */
+  eslint?: ESLint;
+  /** 린트 대상 파일이 있을 때만 초기화됨 */
+  results?: ESLint.LintResult[];
+}
+
+//#endregion
+
+//#region Utilities
+
+/** ESLint 설정 파일 탐색 순서 */
+const ESLINT_CONFIG_FILES = ["eslint.config.ts", "eslint.config.mts", "eslint.config.js", "eslint.config.mjs"] as const;
+
+/**
+ * ignores 속성만 가진 ESLint 설정 객체인지 검사하는 타입 가드
+ */
+function isGlobalIgnoresConfig(item: unknown): item is { ignores: string[] } {
+  if (item == null || typeof item !== "object") return false;
+  if (!("ignores" in item)) return false;
+  if ("files" in item) return false; // files가 있으면 globalIgnores가 아님
+  const ignores = (item as { ignores: unknown }).ignores;
+  if (!Array.isArray(ignores)) return false;
+  return ignores.every((i) => typeof i === "string");
+}
+
+/**
+ * eslint.config.ts/js에서 globalIgnores 패턴을 추출한다.
+ * files 속성 없이 ignores만 있는 설정 객체가 globalIgnores이다.
+ * @internal 테스트용으로 export
+ */
+export async function loadIgnorePatterns(cwd: string): Promise<string[]> {
+  let configPath: string | undefined;
+  for (const f of ESLINT_CONFIG_FILES) {
+    const p = path.join(cwd, f);
+    if (await fsExists(p)) {
+      configPath = p;
+      break;
+    }
+  }
+
+  if (configPath == null) {
+    throw new SdError(`ESLint 설정 파일을 찾을 수 없습니다 (cwd: ${cwd}): ${ESLINT_CONFIG_FILES.join(", ")}`);
+  }
+
+  const jiti = createJiti(import.meta.url);
+  const configModule = await jiti.import(configPath);
+
+  let configs: unknown;
+  if (Array.isArray(configModule)) {
+    configs = configModule;
+  } else if (configModule != null && typeof configModule === "object" && "default" in configModule) {
+    configs = configModule.default;
+  } else {
+    throw new SdError(`ESLint 설정 파일이 올바른 형식이 아닙니다: ${configPath}`);
+  }
+
+  if (!Array.isArray(configs)) {
+    throw new SdError(`ESLint 설정이 배열이 아닙니다: ${configPath}`);
+  }
+
+  return configs.filter(isGlobalIgnoresConfig).flatMap((item) => item.ignores);
+}
+
+//#endregion
+
+//#region Main
+
+/**
+ * ESLint를 실행한다.
+ *
+ * - `eslint.config.ts/js`에서 globalIgnores 패턴을 추출하여 glob 필터링에 적용
+ * - listr2를 사용하여 진행 상황 표시
+ * - 캐시 활성화 (`.cache/eslint.cache`에 저장, 설정 변경 시 자동 무효화)
+ * - 에러 발생 시 `process.exitCode = 1` 설정
+ *
+ * @param options - 린트 실행 옵션
+ * @returns 완료 시 resolve. 에러 발견 시 `process.exitCode`를 1로 설정하고 resolve (throw하지 않음)
+ */
+export async function runLint(options: LintOptions): Promise<void> {
+  const { targets, fix, timing } = options;
+  const cwd = process.cwd();
+  const logger = consola.withTag("sd:cli:lint");
+
+  logger.debug("린트 시작", { targets, fix, timing });
+
+  // TIMING 환경변수 설정
+  if (timing) {
+    process.env["TIMING"] = "1";
+  }
+
+  const listr = new Listr<LintContext, "default" | "verbose">(
+    [
+      {
+        title: "ESLint 설정 로드",
+        task: async (ctx, task) => {
+          ctx.ignorePatterns = await loadIgnorePatterns(cwd);
+          logger.debug("ignore 패턴 로드 완료", { ignorePatternCount: ctx.ignorePatterns.length });
+          task.title = `ESLint 설정 로드 (${ctx.ignorePatterns.length}개 ignore 패턴)`;
+        },
+      },
+      {
+        title: "린트 대상 파일 수집",
+        task: async (ctx, task) => {
+          let files = await fsGlob("**/*.{ts,tsx,js,jsx}", {
+            cwd,
+            ignore: ctx.ignorePatterns,
+            nodir: true,
+            absolute: true,
+          });
+
+          // targets가 주어지면 해당 경로의 하위 파일만 필터링
+          files = pathFilterByTargets(files, targets, cwd);
+          ctx.files = files;
+          logger.debug("파일 수집 완료", { fileCount: files.length });
+          task.title = `린트 대상 파일 수집 (${files.length}개)`;
+
+          if (files.length === 0) {
+            task.skip("린트할 파일이 없습니다.");
+          }
+        },
+      },
+      {
+        title: "린트 실행",
+        enabled: (ctx) => (ctx.files?.length ?? 0) > 0,
+        task: async (ctx, task) => {
+          const files = ctx.files!;
+          task.title = `린트 실행 중... (${files.length}개 파일)`;
+          ctx.eslint = new ESLint({
+            cwd,
+            fix,
+            cache: true,
+            cacheLocation: path.join(cwd, ".cache", "eslint.cache"),
+          });
+          ctx.results = await ctx.eslint.lintFiles(files);
+        },
+      },
+      {
+        title: "자동 수정 적용",
+        enabled: () => fix,
+        skip: (ctx) => (ctx.files?.length ?? 0) === 0 || ctx.results == null,
+        task: async (ctx) => {
+          if (ctx.results == null) return;
+          await ESLint.outputFixes(ctx.results);
+          logger.debug("자동 수정 적용 완료");
+        },
+      },
+    ],
+    {
+      renderer: consola.level >= LogLevels.debug ? "verbose" : "default",
+    },
+  );
+
+  const ctx = await listr.run();
+
+  // 파일이 없거나 린트가 실행되지 않았으면 조기 종료
+  if ((ctx.files?.length ?? 0) === 0 || ctx.results == null || ctx.eslint == null) {
+    logger.info("린트할 파일 없음");
+    return;
+  }
+
+  // 결과 집계
+  const errorCount = ctx.results.sum((r) => r.errorCount);
+  const warningCount = ctx.results.sum((r) => r.warningCount);
+
+  if (errorCount > 0) {
+    logger.error("린트 에러 발생", { errorCount, warningCount });
+  } else if (warningCount > 0) {
+    logger.info("린트 완료 (경고 있음)", { errorCount, warningCount });
+  } else {
+    logger.info("린트 완료", { errorCount, warningCount });
+  }
+
+  // 포맷터 출력
+  const formatter = await ctx.eslint.loadFormatter("stylish");
+  const resultText = await formatter.format(ctx.results);
+  if (resultText) {
+    process.stdout.write(resultText);
+  }
+
+  // 에러 있으면 exit code 1
+  if (errorCount > 0) {
+    process.exitCode = 1;
+  }
+}
+
+//#endregion