@seed-design/cli 1.2.1 → 1.2.2

package/src/commands/init.ts

@@ -1,9 +1,9 @@
 import * as p from "@clack/prompts";
-import fs from "fs-extra";
-import path from "path";
 import { z } from "zod";
 import { analytics } from "../utils/analytics";
 import { highlight } from "../utils/color";
+import { handleCliError, isCliCancelError, isVerboseMode } from "../utils/error";
+import { DEFAULT_INIT_CONFIG, promptInitConfig, writeInitConfigFile } from "../utils/init-config";
 
 import type { Config } from "@/src/utils/get-config";
 
@@ -13,6 +13,7 @@ import dedent from "dedent";
 const initOptionsSchema = z.object({
   cwd: z.string(),
   yes: z.boolean().optional(),
+  default: z.boolean().optional(),
 });
 
 export const initCommand = (cli: CAC) => {
@@ -22,64 +23,38 @@ export const initCommand = (cli: CAC) => {
       default: process.cwd(),
     })
     .option("-y, --yes", "모든 질문에 대해 기본값으로 답변합니다.")
+    .option("--default", "Deprecated. --yes와 동일하게 기본값으로 생성합니다.")
     .action(async (opts) => {
       const startTime = Date.now();
+      const verbose = isVerboseMode(opts);
       p.intro("seed-design.json 파일 생성");
 
-      const options = initOptionsSchema.parse(opts);
-      const isYesOption = options.yes;
-      let config: Config = {
-        rsc: false,
-        tsx: true,
-        path: "./seed-design",
-        telemetry: true,
-      };
-
-      if (!isYesOption) {
-        const group = await p.group(
-          {
-            tsx: () =>
-              p.confirm({
-                message: `${highlight("TypeScript")}를 사용중이신가요?`,
-                initialValue: true,
-              }),
-            rsc: () =>
-              p.confirm({
-                message: `${highlight("React Server Components")}를 사용중이신가요?`,
-                initialValue: false,
-              }),
-            path: () =>
-              p.text({
-                message: `${highlight("seed-design 폴더")} 경로를 입력해주세요. (기본값은 프로젝트 루트에 생성됩니다.)`,
-                initialValue: "./seed-design",
-                defaultValue: "./seed-design",
-                placeholder: "./seed-design",
-              }),
-            telemetry: () =>
-              p.confirm({
-                message: `개선을 위해 ${highlight("익명 사용 데이터")}를 수집할까요?`,
-                initialValue: true,
-              }),
-          },
-          {
-            onCancel: () => {
-              p.cancel("작업이 취소됐어요.");
-              process.exit(0);
-            },
-          },
-        );
+      try {
+        const parsed = initOptionsSchema.safeParse(opts);
+        if (!parsed.success) {
+          throw parsed.error;
+        }
 
-        config = {
-          ...group,
-        };
-      }
+        const options = parsed.data;
+        const isDefaultMode = options.yes || options.default;
+        const config: Config = isDefaultMode ? DEFAULT_INIT_CONFIG : await promptInitConfig();
 
-      try {
         const { start, stop } = p.spinner();
         start("seed-design.json 파일 생성중...");
-        const targetPath = path.resolve(options.cwd, "seed-design.json");
-        await fs.writeFile(targetPath, `${JSON.stringify(config, null, 2)}\n`, "utf-8");
-        const relativePath = path.relative(process.cwd(), targetPath);
+        const relativePath = await (async () => {
+          try {
+            const result = await writeInitConfigFile({
+              cwd: options.cwd,
+              config,
+            });
+
+            return result.relativePath;
+          } catch (error) {
+            stop("seed-design.json 파일 생성이 중단됐어요.");
+            throw error;
+          }
+        })();
+
         stop(`seed-design.json 파일이 ${highlight(relativePath)}에 생성됐어요.`);
 
         p.log.info(highlight("seed-design add {component} 명령어로 컴포넌트를 추가해보세요!"));
@@ -99,23 +74,37 @@ export const initCommand = (cli: CAC) => {
         );
 
         p.outro("작업이 완료됐어요.");
+
+        // init 성공 이벤트 추적
+        const duration = Date.now() - startTime;
+        try {
+          await analytics.track(options.cwd, {
+            event: "init",
+            properties: {
+              tsx: config.tsx,
+              rsc: config.rsc,
+              telemetry: config.telemetry,
+              yes_option: isDefaultMode,
+              duration_ms: duration,
+            },
+          });
+        } catch (telemetryError) {
+          if (verbose) {
+            console.error("[Telemetry] init tracking failed:", telemetryError);
+          }
+        }
       } catch (error) {
-        p.log.error(`seed-design.json 파일 생성에 실패했어요. ${error}`);
-        p.outro(highlight("작업이 취소됐어요."));
+        if (isCliCancelError(error)) {
+          p.outro(highlight(error.message));
+          process.exit(0);
+        }
+
+        handleCliError(error, {
+          defaultMessage: "seed-design.json 파일 생성에 실패했어요.",
+          defaultHint: "`--verbose` 옵션으로 상세 오류를 확인해보세요.",
+          verbose,
+        });
         process.exit(1);
       }
-
-      // init 성공 이벤트 추적
-      const duration = Date.now() - startTime;
-      await analytics.track(options.cwd, {
-        event: "init",
-        properties: {
-          tsx: config.tsx,
-          rsc: config.rsc,
-          telemetry: config.telemetry,
-          yes_option: isYesOption,
-          duration_ms: duration,
-        },
-      });
     });
 };

package/src/index.ts

@@ -2,6 +2,7 @@
 
 import { addCommand } from "@/src/commands/add";
 import { addAllCommand } from "@/src/commands/add-all";
+import { compatCommand } from "@/src/commands/compat";
 import { initCommand } from "@/src/commands/init";
 import { getPackageInfo } from "@/src/utils/get-package-info";
 import { cac } from "cac";
@@ -12,9 +13,12 @@ const CLI = cac(NAME);
 async function main() {
   const packageInfo = getPackageInfo();
 
+  CLI.option("--verbose", "오류 상세 정보를 출력합니다.");
+
   /* Commands */
   addCommand(CLI);
   addAllCommand(CLI);
+  compatCommand(CLI);
   initCommand(CLI);
 
   CLI.version(packageInfo.version || "1.0.0", "-v, --version");

package/src/schema.ts

@@ -27,7 +27,13 @@ export const publicRegistryItemSchema = z.object({
 
   ///////////////////////////////////////////////////////////////
 
-  snippets: z.array(z.object({ path: z.string(), content: z.string() })),
+  snippets: z.array(
+    z.object({
+      path: z.string(),
+      dependencies: z.record(z.string(), z.string()).optional(),
+      content: z.string(),
+    }),
+  ),
 });
 
 /**
@@ -41,7 +47,14 @@ export const publicRegistrySchema = z.object({
   items: z.array(
     publicRegistryItemSchema
       .omit({ snippets: true })
-      .extend({ snippets: z.array(z.object({ path: z.string() })) }),
+      .extend({
+        snippets: z.array(
+          z.object({
+            path: z.string(),
+            dependencies: z.record(z.string(), z.string()).optional(),
+          }),
+        ),
+      }),
   ),
 });
 

package/src/tests/compatibility.test.ts

@@ -0,0 +1,148 @@
+import { afterEach, describe, expect, it } from "bun:test";
+import fs from "fs-extra";
+import os from "os";
+import path from "path";
+import type { PublicRegistry } from "@/src/schema";
+import {
+  analyzeRegistryItemCompatibility,
+  findInstalledSnippetItemKeys,
+} from "../utils/compatibility";
+
+const registries: PublicRegistry[] = [
+  {
+    id: "ui",
+    items: [
+      {
+        id: "action-button",
+        snippets: [
+          {
+            path: "action-button.tsx",
+            dependencies: {
+              "@seed-design/react": "~1.0.0",
+              "@seed-design/css": "~1.0.0",
+            },
+          },
+        ],
+      },
+      {
+        id: "checkbox",
+        snippets: [
+          {
+            path: "checkbox.tsx",
+            dependencies: {
+              "@seed-design/react": "~1.2.0",
+              "@seed-design/css": "~1.2.0",
+            },
+          },
+        ],
+      },
+    ],
+  },
+];
+
+describe("analyzeRegistryItemCompatibility", () => {
+  it("정확한 버전이 모두 호환되면 이슈가 없어야 함", () => {
+    const report = analyzeRegistryItemCompatibility({
+      publicRegistries: registries,
+      itemKeys: ["ui:action-button"],
+      projectPackageVersions: {
+        "@seed-design/react": "1.0.9",
+        "@seed-design/css": "1.0.2",
+      },
+    });
+
+    expect(report.issues).toHaveLength(0);
+  });
+
+  it("요구 범위를 만족하지 못하면 incompatible 이슈를 리턴해야 함", () => {
+    const report = analyzeRegistryItemCompatibility({
+      publicRegistries: registries,
+      itemKeys: ["ui:checkbox"],
+      projectPackageVersions: {
+        "@seed-design/react": "1.1.0",
+        "@seed-design/css": "1.2.1",
+      },
+    });
+
+    expect(report.issues).toHaveLength(1);
+    expect(report.issues[0]).toMatchObject({
+      itemKey: "ui:checkbox",
+      packageName: "@seed-design/react",
+      type: "incompatible-version",
+    });
+  });
+
+  it("패키지가 없으면 missing-package 이슈를 리턴해야 함", () => {
+    const report = analyzeRegistryItemCompatibility({
+      publicRegistries: registries,
+      itemKeys: ["ui:action-button"],
+      projectPackageVersions: {
+        "@seed-design/react": "1.0.9",
+      },
+    });
+
+    expect(report.issues).toHaveLength(1);
+    expect(report.issues[0]).toMatchObject({
+      itemKey: "ui:action-button",
+      packageName: "@seed-design/css",
+      type: "missing-package",
+    });
+  });
+
+  it("workspace range처럼 버전 스펙이 range여도 교집합이 있으면 호환으로 처리해야 함", () => {
+    const report = analyzeRegistryItemCompatibility({
+      publicRegistries: registries,
+      itemKeys: ["ui:action-button"],
+      projectPackageVersions: {
+        "@seed-design/react": "workspace:^1.0.0",
+        "@seed-design/css": "workspace:^1.0.0",
+      },
+    });
+
+    expect(report.issues).toHaveLength(0);
+  });
+
+  it("해석할 수 없는 버전 스펙이면 invalid-version-spec 이슈를 리턴해야 함", () => {
+    const report = analyzeRegistryItemCompatibility({
+      publicRegistries: registries,
+      itemKeys: ["ui:action-button"],
+      projectPackageVersions: {
+        "@seed-design/react": "workspace:*",
+        "@seed-design/css": "1.0.2",
+      },
+    });
+
+    expect(report.issues).toHaveLength(1);
+    expect(report.issues[0]).toMatchObject({
+      itemKey: "ui:action-button",
+      packageName: "@seed-design/react",
+      type: "invalid-version-spec",
+    });
+  });
+});
+
+describe("findInstalledSnippetItemKeys", () => {
+  const tempDirs: string[] = [];
+
+  afterEach(async () => {
+    while (tempDirs.length > 0) {
+      const dir = tempDirs.pop();
+      if (dir) await fs.remove(dir);
+    }
+  });
+
+  it("jsx/js 변환 케이스도 설치된 스니펫으로 인식해야 함", async () => {
+    const rootPath = await fs.mkdtemp(path.join(os.tmpdir(), "seed-cli-compat-"));
+    tempDirs.push(rootPath);
+
+    await fs.ensureDir(path.join(rootPath, "ui"));
+    await fs.writeFile(path.join(rootPath, "ui", "action-button.jsx"), "export {};");
+
+    const installed = findInstalledSnippetItemKeys({
+      publicRegistries: registries,
+      rootPath,
+    });
+
+    expect(installed).toEqual(["ui:action-button"]);
+  });
+});

package/src/tests/resolve-dependencies.test.ts

@@ -1,4 +1,4 @@
-import { describe, it, expect } from "vitest";
+import { describe, it, expect } from "bun:test";
 import { resolveDependencies } from "../utils/resolve-dependencies";
 import type { PublicRegistry } from "@/src/schema";
 

package/src/utils/analytics.ts

@@ -1,6 +1,6 @@
 import { randomUUID } from "node:crypto";
 import * as p from "@clack/prompts";
-import { getConfig } from "./get-config";
+import { getRawConfig } from "./get-config";
 
 const EVENT_PREFIX = "seed_cli";
 
@@ -24,7 +24,7 @@ async function isTelemetryEnabled(cwd: string): Promise<boolean> {
 
   // 2. seed-design.json 체크
   try {
-    const config = await getConfig(cwd);
+    const config = await getRawConfig(cwd);
     if (config?.telemetry === false) return false;
   } catch {
     // 설정 파일이 없거나 읽기 실패 시 기본값 사용

package/src/utils/compatibility.ts

@@ -0,0 +1,291 @@
+import type { PublicRegistry } from "@/src/schema";
+import { getPackageInfo } from "@/src/utils/get-package-info";
+import * as p from "@clack/prompts";
+import fs from "fs-extra";
+import path from "path";
+import { intersects, satisfies, valid, validRange } from "semver";
+import { highlight } from "./color";
+
+export const COMPAT_PACKAGE_NAMES = ["@seed-design/react", "@seed-design/css"] as const;
+export type CompatPackageName = (typeof COMPAT_PACKAGE_NAMES)[number];
+
+const WORKSPACE_VERSION_PREFIX = "workspace:";
+const NPM_ALIAS_PREFIX = "npm:";
+
+export interface CompatibilityIssue {
+  itemKey: string;
+  packageName: CompatPackageName;
+  requiredRanges: string[];
+  installedVersionSpec?: string;
+  type: "missing-package" | "invalid-version-spec" | "incompatible-version";
+}
+
+export interface CompatibilityReport {
+  checkedItemKeys: string[];
+  projectPackageVersions: Partial<Record<CompatPackageName, string>>;
+  issues: CompatibilityIssue[];
+}
+
+export function getProjectSeedPackageVersionSpecs(
+  cwd: string,
+): Partial<Record<CompatPackageName, string>> {
+  try {
+    const packageInfo = getPackageInfo(cwd);
+    const packageDeps = {
+      ...packageInfo.dependencies,
+      ...packageInfo.devDependencies,
+      ...packageInfo.peerDependencies,
+      ...packageInfo.optionalDependencies,
+    };
+    const result: Partial<Record<CompatPackageName, string>> = {};
+
+    for (const packageName of COMPAT_PACKAGE_NAMES) {
+      const value = packageDeps[packageName];
+      if (typeof value === "string") {
+        result[packageName] = value;
+      }
+    }
+
+    return result;
+  } catch {
+    return {};
+  }
+}
+
+export function analyzeRegistryItemCompatibility({
+  publicRegistries,
+  itemKeys,
+  projectPackageVersions,
+}: {
+  publicRegistries: PublicRegistry[];
+  itemKeys: string[];
+  projectPackageVersions: Partial<Record<CompatPackageName, string>>;
+}): CompatibilityReport {
+  const checkedItemKeys = Array.from(new Set(itemKeys));
+  const itemMap = new Map<string, PublicRegistry["items"][number]>(
+    publicRegistries.flatMap((registry) =>
+      registry.items.map((item) => [`${registry.id}:${item.id}`, item] as const),
+    ),
+  );
+
+  const issues: CompatibilityIssue[] = [];
+
+  for (const itemKey of checkedItemKeys) {
+    const item = itemMap.get(itemKey);
+    if (!item) continue;
+
+    const requiredRangesByPackage = collectRequiredRangesByPackage(item);
+
+    for (const packageName of COMPAT_PACKAGE_NAMES) {
+      const requiredRanges = Array.from(requiredRangesByPackage[packageName] ?? []);
+
+      if (!requiredRanges.length) continue;
+
+      const installedVersionSpec = projectPackageVersions[packageName];
+
+      if (!installedVersionSpec) {
+        issues.push({
+          itemKey,
+          packageName,
+          requiredRanges,
+          type: "missing-package",
+        });
+        continue;
+      }
+
+      const normalizedVersionSpec = normalizeVersionSpec(installedVersionSpec);
+
+      if (!normalizedVersionSpec) {
+        issues.push({
+          itemKey,
+          packageName,
+          requiredRanges,
+          installedVersionSpec,
+          type: "invalid-version-spec",
+        });
+        continue;
+      }
+
+      const isRangeCompatible = requiredRanges.every((requiredRange) =>
+        isVersionCompatible({
+          currentVersionSpec: normalizedVersionSpec,
+          requiredRange,
+        }),
+      );
+
+      if (!isRangeCompatible) {
+        issues.push({
+          itemKey,
+          packageName,
+          requiredRanges,
+          installedVersionSpec,
+          type: "incompatible-version",
+        });
+      }
+    }
+  }
+
+  return {
+    checkedItemKeys,
+    projectPackageVersions,
+    issues,
+  };
+}
+
+export function logCompatibilityReport({
+  report,
+  title,
+}: {
+  report: CompatibilityReport;
+  title: string;
+}) {
+  if (!report.issues.length) return;
+
+  p.log.warn(title);
+  p.log.info(
+    `현재 프로젝트 버전: ${COMPAT_PACKAGE_NAMES.map((packageName) => `${packageName}@${highlight(report.projectPackageVersions[packageName] ?? "미설치")}`).join(", ")}`,
+  );
+
+  const issuesByItem = new Map<string, CompatibilityIssue[]>();
+
+  for (const issue of report.issues) {
+    const found = issuesByItem.get(issue.itemKey) ?? [];
+    found.push(issue);
+    issuesByItem.set(issue.itemKey, found);
+  }
+
+  for (const [itemKey, issues] of issuesByItem.entries()) {
+    p.log.warn(highlight(itemKey));
+
+    for (const issue of issues) {
+      const required = issue.requiredRanges.join(" | ");
+
+      if (issue.type === "missing-package") {
+        p.log.info(
+          `  - ${issue.packageName}: 패키지가 설치되어 있지 않아요. 필요 범위: ${required}`,
+        );
+        continue;
+      }
+
+      if (issue.type === "invalid-version-spec") {
+        p.log.info(
+          `  - ${issue.packageName}: 현재 버전 형식을 해석하지 못했어요 (${issue.installedVersionSpec}). 필요 범위: ${required}`,
+        );
+        continue;
+      }
+
+      p.log.info(
+        `  - ${issue.packageName}: 현재 ${issue.installedVersionSpec}, 필요 범위 ${required}`,
+      );
+    }
+  }
+}
+
+export function findInstalledSnippetItemKeys({
+  publicRegistries,
+  rootPath,
+}: {
+  publicRegistries: PublicRegistry[];
+  rootPath: string;
+}): string[] {
+  const installedItemKeys: string[] = [];
+
+  for (const registry of publicRegistries) {
+    for (const item of registry.items) {
+      const isInstalled = item.snippets.some((snippet) =>
+        getSnippetPathCandidates(snippet.path).some((snippetPath) =>
+          fs.existsSync(path.join(rootPath, registry.id, snippetPath)),
+        ),
+      );
+
+      if (isInstalled) {
+        installedItemKeys.push(`${registry.id}:${item.id}`);
+      }
+    }
+  }
+
+  return installedItemKeys;
+}
+
+function collectRequiredRangesByPackage(item: PublicRegistry["items"][number]) {
+  const requiredRangesByPackage = Object.fromEntries(
+    COMPAT_PACKAGE_NAMES.map((packageName) => [packageName, new Set<string>()]),
+  ) as Record<CompatPackageName, Set<string>>;
+
+  for (const snippet of item.snippets) {
+    for (const [packageName, requiredRange] of Object.entries(snippet.dependencies ?? {})) {
+      if (!isCompatPackageName(packageName)) continue;
+      requiredRangesByPackage[packageName].add(requiredRange);
+    }
+  }
+
+  return requiredRangesByPackage;
+}
+
+function normalizeVersionSpec(versionSpec: string): string | null {
+  let normalized = versionSpec.trim();
+
+  if (normalized.startsWith(WORKSPACE_VERSION_PREFIX)) {
+    normalized = normalized.slice(WORKSPACE_VERSION_PREFIX.length).trim();
+  }
+
+  if (normalized.startsWith(NPM_ALIAS_PREFIX)) {
+    const aliasVersionToken = normalized.split("@").at(-1);
+    if (!aliasVersionToken) return null;
+    normalized = aliasVersionToken;
+  }
+
+  if (!normalized || normalized === "*") return null;
+
+  if (valid(normalized)) return normalized;
+  if (validRange(normalized)) return normalized;
+
+  return null;
+}
+
+function isVersionCompatible({
+  currentVersionSpec,
+  requiredRange,
+}: {
+  currentVersionSpec: string;
+  requiredRange: string;
+}) {
+  const normalizedRequiredRange = validRange(requiredRange);
+  if (!normalizedRequiredRange) return false;
+
+  if (valid(currentVersionSpec)) {
+    return satisfies(currentVersionSpec, normalizedRequiredRange, {
+      includePrerelease: true,
+    });
+  }
+
+  return intersects(currentVersionSpec, normalizedRequiredRange, {
+    includePrerelease: true,
+  });
+}
+
+function getSnippetPathCandidates(originalPath: string): string[] {
+  const candidates = new Set([originalPath]);
+
+  if (originalPath.endsWith(".tsx")) {
+    candidates.add(`${originalPath.slice(0, -4)}.jsx`);
+  }
+
+  if (originalPath.endsWith(".ts")) {
+    candidates.add(`${originalPath.slice(0, -3)}.js`);
+  }
+
+  if (originalPath.endsWith(".jsx")) {
+    candidates.add(`${originalPath.slice(0, -4)}.tsx`);
+  }
+
+  if (originalPath.endsWith(".js")) {
+    candidates.add(`${originalPath.slice(0, -3)}.ts`);
+  }
+
+  return Array.from(candidates);
+}
+
+function isCompatPackageName(packageName: string): packageName is CompatPackageName {
+  return COMPAT_PACKAGE_NAMES.includes(packageName as CompatPackageName);
+}