@seed-design/cli 1.2.1 → 1.3.0

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,9 +1,9 @@
-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";
 
 describe("resolveDependencies", () => {
-  it("should resolve a simple item without dependencies", () => {
+  it("의존성이 없는 단일 아이템을 해석해야 한다", () => {
     const publicRegistries: PublicRegistry[] = [
       {
         id: "ui",
@@ -36,7 +36,7 @@ describe("resolveDependencies", () => {
     expect(result.npmDependenciesToAdd.size).toBe(0);
   });
 
-  it("should resolve npm dependencies", () => {
+  it("npm 의존성을 수집해야 한다", () => {
     const publicRegistries: PublicRegistry[] = [
       {
         id: "ui",
@@ -61,7 +61,7 @@ describe("resolveDependencies", () => {
     expect(result.npmDependenciesToAdd.has("clsx")).toBe(true);
   });
 
-  it("should resolve inner dependencies recursively", () => {
+  it("innerDependencies를 재귀적으로 해석해야 한다", () => {
     const publicRegistries: PublicRegistry[] = [
       {
         id: "ui",
@@ -131,7 +131,7 @@ describe("resolveDependencies", () => {
     expect(result.npmDependenciesToAdd.has("framer-motion")).toBe(true);
   });
 
-  it("should handle multiple selected items", () => {
+  it("여러 선택 아이템을 함께 처리해야 한다", () => {
     const publicRegistries: PublicRegistry[] = [
       {
         id: "ui",
@@ -161,7 +161,7 @@ describe("resolveDependencies", () => {
     expect(result.registryItemsToAdd[0].items.map((i) => i.id)).toEqual(["button", "chip"]);
   });
 
-  it("should prevent duplicate items", () => {
+  it("중복 아이템을 제거해야 한다", () => {
     const publicRegistries: PublicRegistry[] = [
       {
         id: "ui",
@@ -186,7 +186,7 @@ describe("resolveDependencies", () => {
       },
     ];
 
-    // Select both dialog and button, but button is already a dependency of dialog
+    // dialog와 button을 동시에 선택해도 button은 dialog 의존성으로 이미 포함된다.
     const result = resolveDependencies({
       selectedItemKeys: ["ui:dialog", "ui:button"],
       publicRegistries,
@@ -194,12 +194,12 @@ describe("resolveDependencies", () => {
 
     expect(result.registryItemsToAdd).toHaveLength(1);
     expect(result.registryItemsToAdd[0].items).toHaveLength(2);
-    // Button should appear only once
+    // button은 한 번만 포함되어야 한다.
     const buttonCount = result.registryItemsToAdd[0].items.filter((i) => i.id === "button").length;
     expect(buttonCount).toBe(1);
   });
 
-  it("should handle nested inner dependencies", () => {
+  it("중첩된 innerDependencies를 처리해야 한다", () => {
     const publicRegistries: PublicRegistry[] = [
       {
         id: "ui",
@@ -268,7 +268,7 @@ describe("resolveDependencies", () => {
     expect(result.npmDependenciesToAdd.has("lodash")).toBe(true);
   });
 
-  it("should throw error for invalid snippet format", () => {
+  it("잘못된 스니펫 포맷이면 에러를 던져야 한다", () => {
     const publicRegistries: PublicRegistry[] = [];
 
     expect(() =>
@@ -279,7 +279,7 @@ describe("resolveDependencies", () => {
     ).toThrowError('Invalid snippet format: "invalid-format"');
   });
 
-  it("should throw error for non-existent snippet", () => {
+  it("존재하지 않는 스니펫이면 에러를 던져야 한다", () => {
     const publicRegistries: PublicRegistry[] = [
       {
         id: "ui",
@@ -295,7 +295,7 @@ describe("resolveDependencies", () => {
     ).toThrowError('Cannot find snippet: "ui:non-existent"');
   });
 
-  it("should throw error for missing inner dependency", () => {
+  it("inner dependency가 누락되면 에러를 던져야 한다", () => {
     const publicRegistries: PublicRegistry[] = [
       {
         id: "ui",
@@ -327,7 +327,7 @@ describe("resolveDependencies", () => {
     ).toThrowError("Cannot find dependency item: breeze:missing");
   });
 
-  it("should handle multiple registries with multiple items", () => {
+  it("여러 레지스트리와 아이템을 함께 처리해야 한다", () => {
     const publicRegistries: PublicRegistry[] = [
       {
         id: "ui",
@@ -378,7 +378,7 @@ describe("resolveDependencies", () => {
     expect(result.npmDependenciesToAdd.has("framer-motion")).toBe(true);
   });
 
-  it("should collect all npm dependencies from nested dependencies", () => {
+  it("중첩 의존성의 npm 패키지를 모두 수집해야 한다", () => {
     const publicRegistries: PublicRegistry[] = [
       {
         id: "ui",

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 {
     // 설정 파일이 없거나 읽기 실패 시 기본값 사용
@@ -60,9 +60,8 @@ async function track(cwd: string, { event, properties = {} }: TrackOptions): Pro
 
   const fullEvent = `${EVENT_PREFIX}.${event}`;
 
-  // Dev 모드: 콘솔에만 출력
+  // Dev 모드: 텔레메트리 전송 생략
   if (process.env.NODE_ENV === "dev") {
-    console.log(`📊 [Telemetry] ${fullEvent}`, properties);
     return;
   }
 

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);
+}