@spfn/cms 0.1.0-alpha.7 → 0.1.0-alpha.70

package/dist/server/generators/index.js

@@ -0,0 +1,753 @@
+// src/server/generators/label-sync-generator.ts
+import { logger } from "@spfn/core/logger";
+import { join as join2, relative, extname as extname2 } from "path";
+import { existsSync as existsSync2, readdirSync as readdirSync2, readFileSync as readFileSync2, statSync as statSync2 } from "fs";
+
+// src/server/helpers/sync.ts
+import { existsSync, readdirSync, readFileSync, statSync } from "fs";
+import { basename, extname, join } from "path";
+
+// src/server/labels/helpers.ts
+function flattenLabels(labels) {
+  const result = [];
+  function isLabelDefinition(obj) {
+    return "key" in obj && "defaultValue" in obj && typeof obj.key === "string" && (typeof obj.defaultValue === "string" || typeof obj.defaultValue === "object");
+  }
+  function traverse(obj) {
+    if (isLabelDefinition(obj)) {
+      result.push({
+        key: obj.key,
+        defaultValue: obj.defaultValue,
+        description: obj.description
+      });
+    } else {
+      Object.values(obj).forEach((value) => {
+        if (typeof value === "object" && value !== null) {
+          traverse(value);
+        }
+      });
+    }
+  }
+  traverse(labels);
+  return result;
+}
+function extractLabels(definition) {
+  return flattenLabels(definition.labels);
+}
+
+// src/server/repositories/cms-labels.repository.ts
+import { findOne, findMany as findManyHelper, create as createHelper, updateOne, deleteOne, count as countHelper } from "@spfn/core/db";
+import { desc } from "drizzle-orm";
+
+// src/server/entities/cms-labels.ts
+import { index, integer, serial, text, timestamp } from "drizzle-orm/pg-core";
+import { createFunctionSchema } from "@spfn/core/db";
+var schema = createFunctionSchema("@spfn/cms");
+var cmsLabels = schema.table("labels", {
+  // Primary Key
+  id: serial("id").primaryKey(),
+  // 라벨 식별자
+  key: text("key").notNull().unique(),
+  // 예: "home.hero.title", "why-futureplay.hero.subtitle"
+  // 구조: {section}.{component}.{property}
+  // 섹션 분류 (페이지 단위)
+  section: text("section").notNull(),
+  // 예: "home", "why-futureplay", "team"
+  // 값 타입
+  type: text("type").notNull(),
+  // "text" | "image" | "video" | "file" | "object"
+  // 기본값
+  defaultValue: text("default_value"),
+  // 라벨의 기본값 (sync 시 설정)
+  // 설명
+  description: text("description"),
+  // 라벨에 대한 설명 (optional)
+  // 현재 발행된 버전 번호
+  publishedVersion: integer("published_version"),
+  // null = 미발행 상태
+  // 1, 2, 3... = 발행된 버전 번호
+  // 생성자 추적
+  createdBy: text("created_by"),
+  // 타임스탬프
+  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+  updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow()
+}, (table) => [
+  // 인덱스: 섹션별 조회 최적화
+  index("cms_labels_section_idx").on(table.section),
+  // 인덱스: key로 조회 최적화 (unique 제약으로 자동 생성되지만 명시)
+  index("cms_labels_key_idx").on(table.key)
+]);
+
+// src/server/entities/cms-label-values.ts
+import { serial as serial2, integer as integer2, text as text2, jsonb, timestamp as timestamp2, index as index2, unique } from "drizzle-orm/pg-core";
+import { createFunctionSchema as createFunctionSchema2 } from "@spfn/core/db";
+var schema2 = createFunctionSchema2("@spfn/cms");
+var cmsLabelValues = schema2.table("label_values", {
+  // Primary Key
+  id: serial2("id").primaryKey(),
+  // Foreign Key: cms_labels
+  labelId: integer2("label_id").notNull().references(() => cmsLabels.id, { onDelete: "cascade" }),
+  // 버전 번호 (null = draft, number = published version)
+  version: integer2("version"),
+  // 언어 코드
+  locale: text2("locale").notNull().default("ko"),
+  // "ko" | "en" | "ja"
+  // 반응형 브레이크포인트
+  breakpoint: text2("breakpoint"),
+  // null = 기본값 (모든 화면 크기)
+  // "sm" | "md" | "lg" | "xl" | "2xl"
+  // 실제 값 (JSONB)
+  value: jsonb("value").notNull(),
+  // LabelValue 타입:
+  // - TextValue: { type: "text", content: string }
+  // - ImageValue: { type: "image", url: string, alt?: string, width?: number, height?: number }
+  // - VideoValue: { type: "video", url: string, thumbnail?: string, duration?: number }
+  // - FileValue: { type: "file", url: string, filename: string, size?: number }
+  // - ObjectValue: { type: "object", fields: Record<string, LabelValue> }
+  // 생성 시각
+  createdAt: timestamp2("created_at", { withTimezone: true }).notNull().defaultNow()
+}, (table) => [
+  // UNIQUE 제약: 같은 버전에서 locale + breakpoint 조합은 유일
+  unique("cms_label_values_locale_breakpoint_unique").on(table.labelId, table.version, table.locale, table.breakpoint),
+  // 인덱스: labelId + version 복합 조회 최적화
+  index2("cms_label_values_label_version_idx").on(table.labelId, table.version),
+  // 인덱스: locale 필터링 최적화
+  index2("cms_label_values_locale_idx").on(table.locale)
+]);
+
+// src/server/entities/cms-label-versions.ts
+import { serial as serial3, integer as integer3, text as text3, timestamp as timestamp3, index as index3, unique as unique2 } from "drizzle-orm/pg-core";
+import { createFunctionSchema as createFunctionSchema3 } from "@spfn/core/db";
+var schema3 = createFunctionSchema3("@spfn/cms");
+var cmsLabelVersions = schema3.table("label_versions", {
+  // Primary Key
+  id: serial3("id").primaryKey(),
+  // Foreign Key: cms_labels
+  labelId: integer3("label_id").notNull().references(() => cmsLabels.id, { onDelete: "cascade" }),
+  // 버전 번호
+  version: integer3("version").notNull(),
+  // 버전 상태
+  status: text3("status").notNull(),
+  // "draft" | "published" | "archived"
+  // 발행 정보
+  publishedAt: timestamp3("published_at", { withTimezone: true }),
+  publishedBy: text3("published_by"),
+  // 버전 노트 (변경사항 설명)
+  notes: text3("notes"),
+  // 버전 생성자
+  createdBy: text3("created_by"),
+  // 생성 시각
+  createdAt: timestamp3("created_at", { withTimezone: true }).notNull().defaultNow()
+}, (table) => [
+  // UNIQUE 제약: 각 라벨의 버전 번호는 고유
+  unique2("cms_label_versions_label_version_unique").on(table.labelId, table.version),
+  // 인덱스: labelId로 버전 목록 조회 최적화
+  index3("cms_label_versions_label_id_idx").on(table.labelId),
+  // 인덱스: status 필터링 최적화
+  index3("cms_label_versions_status_idx").on(table.status)
+]);
+
+// src/server/entities/cms-draft-cache.ts
+import { serial as serial4, text as text4, jsonb as jsonb2, timestamp as timestamp4, index as index4, unique as unique3 } from "drizzle-orm/pg-core";
+import { createFunctionSchema as createFunctionSchema4 } from "@spfn/core/db";
+var schema4 = createFunctionSchema4("@spfn/cms");
+var cmsDraftCache = schema4.table("draft_cache", {
+  // Primary Key
+  id: serial4("id").primaryKey(),
+  // 섹션 (페이지 단위)
+  section: text4("section").notNull(),
+  // "home" | "why-futureplay" | "team" | "our-companies" | "apply"
+  // 언어
+  locale: text4("locale").notNull(),
+  // "ko" | "en" | "ja"
+  // 사용자 ID (핵심 필드!)
+  userId: text4("user_id").notNull(),
+  // 각 관리자의 독립적인 작업 공간
+  // Draft 콘텐츠 (JSONB)
+  content: jsonb2("content").notNull(),
+  // Record<string, LabelValue>
+  // {
+  //   "home.hero.title": { type: "text", content: "수정 중..." },
+  //   "home.hero.subtitle": { type: "text", content: "새로운 문구" },
+  //   ...
+  // }
+  // 최종 수정 시각
+  updatedAt: timestamp4("updated_at", { withTimezone: true }).notNull().defaultNow()
+}, (table) => [
+  // UNIQUE 제약: section + locale + userId 조합은 유일
+  unique3("cms_draft_cache_unique").on(table.section, table.locale, table.userId),
+  // 인덱스: section으로 조회 최적화
+  index4("cms_draft_cache_section_idx").on(table.section),
+  // 인덱스: userId로 사용자의 모든 draft 조회 최적화
+  index4("cms_draft_cache_user_idx").on(table.userId)
+]);
+
+// src/server/entities/cms-published-cache.ts
+import { serial as serial5, text as text5, jsonb as jsonb3, integer as integer4, timestamp as timestamp5, index as index5, unique as unique4 } from "drizzle-orm/pg-core";
+import { createFunctionSchema as createFunctionSchema5 } from "@spfn/core/db";
+var schema5 = createFunctionSchema5("@spfn/cms");
+var cmsPublishedCache = schema5.table("published_cache", {
+  // Primary Key
+  id: serial5("id").primaryKey(),
+  // 섹션 (페이지 단위)
+  section: text5("section").notNull(),
+  // "home" | "why-futureplay" | "team" | "our-companies" | "apply"
+  // 언어
+  locale: text5("locale").notNull(),
+  // "ko" | "en" | "ja"
+  // 캐시된 콘텐츠 (JSONB)
+  content: jsonb3("content").notNull(),
+  // Record<string, LabelValue>
+  // {
+  //   "home.hero.title": { type: "text", content: "..." },
+  //   "home.hero.image": { type: "image", url: "...", alt: "..." },
+  //   ...
+  // }
+  // 발행 정보
+  publishedAt: timestamp5("published_at", { withTimezone: true }).notNull(),
+  publishedBy: text5("published_by"),
+  // 캐시 버전 (클라이언트 캐싱용)
+  version: integer4("version").notNull().default(1)
+}, (table) => [
+  // UNIQUE 제약: section + locale 조합은 유일
+  unique4("cms_published_cache_unique").on(table.section, table.locale),
+  // 인덱스: section으로 조회 최적화
+  index5("cms_published_cache_section_idx").on(table.section)
+]);
+
+// src/server/entities/cms-audit-logs.ts
+import { serial as serial6, integer as integer5, text as text6, jsonb as jsonb4, timestamp as timestamp6, index as index6 } from "drizzle-orm/pg-core";
+import { createFunctionSchema as createFunctionSchema6 } from "@spfn/core/db";
+var schema6 = createFunctionSchema6("@spfn/cms");
+var cmsAuditLogs = schema6.table("audit_logs", {
+  // Primary Key
+  id: serial6("id").primaryKey(),
+  // Foreign Key: cms_labels (nullable - 라벨 삭제 시 로그는 유지)
+  labelId: integer5("label_id").references(() => cmsLabels.id, { onDelete: "set null" }),
+  // 작업 유형
+  action: text6("action").notNull(),
+  // "create" | "update" | "publish" | "unpublish" | "archive" | "delete" | "rollback" | "duplicate"
+  // 사용자 정보
+  userId: text6("user_id").notNull(),
+  userName: text6("user_name"),
+  // 변경 내용 (before/after)
+  changes: jsonb4("changes"),
+  // { before: {...}, after: {...} }
+  // 추가 메타데이터
+  metadata: jsonb4("metadata"),
+  // { version: number, ip: string, userAgent: string, ... }
+  // 작업 시각
+  createdAt: timestamp6("created_at", { withTimezone: true }).notNull().defaultNow()
+}, (table) => [
+  // 인덱스: labelId로 이력 조회 최적화
+  index6("cms_audit_logs_label_id_idx").on(table.labelId),
+  // 인덱스: userId로 사용자 활동 조회 최적화
+  index6("cms_audit_logs_user_id_idx").on(table.userId),
+  // 인덱스: action 필터링 최적화
+  index6("cms_audit_logs_action_idx").on(table.action),
+  // 인덱스: 시간순 조회 최적화
+  index6("cms_audit_logs_created_at_idx").on(table.createdAt)
+]);
+
+// src/server/repositories/cms-labels.repository.ts
+async function findMany(options) {
+  const { section, limit = 20, offset = 0 } = options || {};
+  return findManyHelper(cmsLabels, {
+    where: section ? { section } : void 0,
+    orderBy: desc(cmsLabels.updatedAt),
+    limit,
+    offset
+  });
+}
+async function count(section) {
+  return countHelper(cmsLabels, section ? { section } : void 0);
+}
+async function findById(id) {
+  return findOne(cmsLabels, { id });
+}
+async function findByKey(key) {
+  return findOne(cmsLabels, { key });
+}
+async function findBySection(section) {
+  return findManyHelper(cmsLabels, {
+    where: { section },
+    orderBy: desc(cmsLabels.updatedAt)
+  });
+}
+async function create(data) {
+  return createHelper(cmsLabels, data);
+}
+async function updateById(id, data) {
+  return updateOne(cmsLabels, { id }, { ...data, updatedAt: /* @__PURE__ */ new Date() });
+}
+async function deleteById(id) {
+  return deleteOne(cmsLabels, { id });
+}
+var cmsLabelsRepository = {
+  findMany,
+  count,
+  findById,
+  findByKey,
+  findBySection,
+  create,
+  updateById,
+  deleteById
+};
+
+// src/server/repositories/cms-label-values.repository.ts
+import { findOne as findOne2, findMany as findMany2, create as create2, updateOne as updateOne2, deleteMany } from "@spfn/core/db";
+import { eq, and, isNull } from "drizzle-orm";
+
+// src/server/repositories/cms-draft-cache.repository.ts
+import { findOne as findOne3, findMany as findMany3, deleteOne as deleteOne2, deleteMany as deleteMany2, upsert as upsertHelper } from "@spfn/core/db";
+import { eq as eq2, and as and2, lt } from "drizzle-orm";
+
+// src/server/repositories/cms-published-cache.repository.ts
+import { findOne as findOne4, findMany as findMany4, deleteOne as deleteOne3, deleteMany as deleteMany3, upsert as upsertHelper2 } from "@spfn/core/db";
+import { eq as eq3, and as and3, sql } from "drizzle-orm";
+async function findBySection2(section, locale = "ko") {
+  return findOne4(
+    cmsPublishedCache,
+    and3(
+      eq3(cmsPublishedCache.section, section),
+      eq3(cmsPublishedCache.locale, locale)
+    )
+  );
+}
+async function upsert(data) {
+  return upsertHelper2(cmsPublishedCache, data, {
+    target: [cmsPublishedCache.section, cmsPublishedCache.locale],
+    set: {
+      content: data.content,
+      publishedAt: data.publishedAt,
+      publishedBy: data.publishedBy,
+      version: sql`${cmsPublishedCache.version} + 1`
+      // 버전 증가로 클라이언트 캐시 무효화
+    }
+  });
+}
+async function findAllLanguages(section) {
+  return findMany4(cmsPublishedCache, {
+    where: eq3(cmsPublishedCache.section, section)
+  });
+}
+async function deleteBySection(section, locale) {
+  if (locale) {
+    await deleteOne3(
+      cmsPublishedCache,
+      and3(
+        eq3(cmsPublishedCache.section, section),
+        eq3(cmsPublishedCache.locale, locale)
+      )
+    );
+  } else {
+    await deleteMany3(
+      cmsPublishedCache,
+      eq3(cmsPublishedCache.section, section)
+    );
+  }
+}
+var cmsPublishedCacheRepository = {
+  findBySection: findBySection2,
+  upsert,
+  findAllLanguages,
+  deleteBySection
+};
+
+// src/server/helpers/sync.ts
+async function syncAll(sections, options = {}) {
+  const results = [];
+  for (const definition of sections) {
+    const result = await syncSection(definition, options);
+    results.push(result);
+  }
+  return results;
+}
+function loadLabelsFromJson(labelsDir) {
+  const sections = [];
+  if (!existsSync(labelsDir)) {
+    console.warn(`[CMS] Labels directory not found: ${labelsDir}`);
+    console.warn(`[CMS] Expected directory structure:`);
+    console.warn(`[CMS]   ${labelsDir}/`);
+    console.warn(`[CMS]     \u251C\u2500\u2500 common/          # Section directory`);
+    console.warn(`[CMS]     \u2502   \u251C\u2500\u2500 messages.json`);
+    console.warn(`[CMS]     \u2502   \u2514\u2500\u2500 errors.json`);
+    console.warn(`[CMS]     \u2514\u2500\u2500 home/            # Section directory`);
+    console.warn(`[CMS]         \u2514\u2500\u2500 hero.json`);
+    return sections;
+  }
+  try {
+    const entries = readdirSync(labelsDir);
+    if (entries.length === 0) {
+      console.warn(`[CMS] Labels directory is empty: ${labelsDir}`);
+      console.warn(`[CMS] Create section directories with JSON files inside`);
+      return sections;
+    }
+    const jsonFiles = entries.filter((e) => extname(e) === ".json");
+    if (jsonFiles.length > 0) {
+      console.warn(`[CMS] Found JSON files directly in ${labelsDir}:`);
+      jsonFiles.forEach((f) => console.warn(`[CMS]   - ${f} (will be ignored)`));
+      console.warn(`[CMS] JSON files should be inside section directories`);
+      console.warn(`[CMS] Example: Move ${jsonFiles[0]} to ${labelsDir}/${basename(jsonFiles[0], ".json")}/${jsonFiles[0]}`);
+    }
+    for (const entry of entries) {
+      const sectionPath = join(labelsDir, entry);
+      const stat = statSync(sectionPath);
+      if (stat.isDirectory()) {
+        const sectionName = entry;
+        const labels = loadSectionLabels(sectionPath);
+        if (Object.keys(labels).length > 0) {
+          sections.push({ section: sectionName, labels });
+        } else {
+          console.warn(`[CMS] Section directory "${sectionName}" has no valid JSON files`);
+        }
+      }
+    }
+    if (sections.length === 0) {
+      console.warn(`[CMS] No valid section directories found in ${labelsDir}`);
+    }
+  } catch (error) {
+    console.warn(`[CMS] Could not scan labels directory: ${labelsDir}`);
+    console.error(`[CMS] Error:`, error);
+  }
+  return sections;
+}
+function loadSectionLabels(sectionPath) {
+  const labels = {};
+  try {
+    const files = readdirSync(sectionPath);
+    for (const file of files) {
+      if (extname(file) === ".json") {
+        const filePath = join(sectionPath, file);
+        const categoryName = basename(file, ".json");
+        try {
+          const content = readFileSync(filePath, "utf-8");
+          labels[categoryName] = JSON.parse(content);
+        } catch (error) {
+          console.warn(`[CMS] Failed to parse ${filePath}`);
+        }
+      }
+    }
+  } catch (error) {
+    console.warn(`[CMS] Could not read section directory: ${sectionPath}`);
+  }
+  return labels;
+}
+async function syncSection(definition, options = {}) {
+  const {
+    dryRun = false,
+    updateExisting = false,
+    removeUnused = false,
+    verbose = false
+  } = options;
+  const { section } = definition;
+  const result = {
+    section,
+    created: 0,
+    updated: 0,
+    deleted: 0,
+    unchanged: 0,
+    errors: []
+  };
+  try {
+    const definedLabels = extractLabels(definition);
+    const definedKeys = new Set(definedLabels.map((l) => l.key));
+    const existingLabels = await cmsLabelsRepository.findBySection(section);
+    const existingMap = new Map(existingLabels.map((l) => [l.key, l]));
+    if (verbose) {
+      console.log(`
+[${section}] Found ${definedLabels.length} labels in definition`);
+      console.log(`[${section}] Found ${existingLabels.length} labels in DB`);
+    }
+    for (const label of definedLabels) {
+      const existing = existingMap.get(label.key);
+      if (!existing) {
+        if (verbose) console.log(`  [CREATE] ${label.key}`);
+        if (!dryRun) {
+          try {
+            const defaultValue = typeof label.defaultValue === "object" ? JSON.stringify(label.defaultValue) : label.defaultValue;
+            await cmsLabelsRepository.create({
+              section,
+              key: label.key,
+              type: label.type || "text",
+              // 라벨 타입 (기본값: 'text')
+              defaultValue,
+              description: label.description
+            });
+          } catch (error) {
+            result.errors.push({
+              key: label.key,
+              error: error instanceof Error ? error.message : String(error)
+            });
+            continue;
+          }
+        }
+        result.created++;
+      } else if (updateExisting) {
+        const newDefaultValue = typeof label.defaultValue === "object" ? JSON.stringify(label.defaultValue) : label.defaultValue;
+        const hasChanged = existing.defaultValue !== newDefaultValue;
+        if (hasChanged) {
+          if (verbose) {
+            console.log(`  [UPDATE] ${label.key}`);
+            console.log(`    Old: "${existing.defaultValue}"`);
+            console.log(`    New: "${newDefaultValue}"`);
+          }
+          if (!dryRun) {
+            try {
+              await cmsLabelsRepository.updateById(existing.id, {
+                defaultValue: newDefaultValue,
+                description: label.description
+              });
+            } catch (error) {
+              result.errors.push({
+                key: label.key,
+                error: error instanceof Error ? error.message : String(error)
+              });
+              continue;
+            }
+          }
+          result.updated++;
+        } else {
+          result.unchanged++;
+        }
+      } else {
+        result.unchanged++;
+      }
+    }
+    if (removeUnused) {
+      for (const existing of existingLabels) {
+        if (!definedKeys.has(existing.key)) {
+          if (verbose) console.log(`  [DELETE] ${existing.key}`);
+          if (!dryRun) {
+            try {
+              await cmsLabelsRepository.deleteById(existing.id);
+            } catch (error) {
+              result.errors.push({
+                key: existing.key,
+                error: error instanceof Error ? error.message : String(error)
+              });
+              continue;
+            }
+          }
+          result.deleted++;
+        }
+      }
+    }
+    if (!dryRun && (result.created > 0 || result.updated > 0 || result.deleted > 0)) {
+      if (verbose) console.log(`  [CACHE] Updating published cache for section: ${section}`);
+      await updatePublishedCache(section);
+    }
+  } catch (error) {
+    result.errors.push({
+      key: "__section__",
+      error: error instanceof Error ? error.message : String(error)
+    });
+  }
+  return result;
+}
+async function updatePublishedCache(section) {
+  const labels = await cmsLabelsRepository.findBySection(section);
+  const localesSet = /* @__PURE__ */ new Set();
+  const labelsByLocale = {};
+  labels.forEach((label) => {
+    try {
+      const parsed = JSON.parse(label.defaultValue || "{}");
+      if (typeof parsed === "object" && !Array.isArray(parsed)) {
+        Object.keys(parsed).forEach((locale) => localesSet.add(locale));
+        Object.entries(parsed).forEach(([locale, value]) => {
+          if (!labelsByLocale[locale]) labelsByLocale[locale] = {};
+          labelsByLocale[locale][label.key] = value;
+        });
+      } else {
+        if (!labelsByLocale.ko) labelsByLocale.ko = {};
+        labelsByLocale.ko[label.key] = label.defaultValue;
+        localesSet.add("ko");
+      }
+    } catch {
+      if (!labelsByLocale.ko) labelsByLocale.ko = {};
+      labelsByLocale.ko[label.key] = label.defaultValue;
+      localesSet.add("ko");
+    }
+  });
+  const timestamp7 = /* @__PURE__ */ new Date();
+  for (const locale of localesSet) {
+    await cmsPublishedCacheRepository.upsert({
+      section,
+      locale,
+      content: labelsByLocale[locale] || {},
+      publishedAt: timestamp7,
+      publishedBy: "system"
+    });
+  }
+}
+
+// src/lib/constants/index.ts
+var DEFAULT_LABELS_DIR = "src/lib/labels";
+
+// src/server/generators/label-sync-generator.ts
+var syncLogger = logger.child("label-sync");
+function createLabelSyncGenerator(config = {}) {
+  const labelsDir = config.labelsDir ?? DEFAULT_LABELS_DIR;
+  const runOn = config.runOn ?? ["watch", "manual", "build"];
+  return {
+    name: "label-sync",
+    watchPatterns: [`${labelsDir}/**/*.json`],
+    runOn,
+    async generate(options) {
+      const labelsPath = join2(options.cwd, labelsDir);
+      if (!existsSync2(labelsPath)) {
+        if (options.debug) {
+          syncLogger.warn(`Labels directory not found: ${labelsPath}`);
+        }
+        return;
+      }
+      try {
+        const changedFile = options.trigger?.changedFile;
+        if (changedFile && changedFile.event === "change") {
+          const success = await attemptIncrementalSync({
+            cwd: options.cwd,
+            labelsPath,
+            changedFilePath: changedFile.path,
+            debug: options.debug
+          });
+          if (success) {
+            if (options.debug) {
+              syncLogger.info("Incremental sync successful");
+            }
+            return;
+          }
+          if (options.debug) {
+            syncLogger.info("Incremental sync failed, doing full sync");
+          }
+        }
+        if (options.debug) {
+          syncLogger.info("Starting full label sync...");
+        }
+        const sections = loadLabelsFromJson(labelsPath);
+        if (sections.length === 0) {
+          syncLogger.warn(`No labels found in ${labelsPath}`);
+          return;
+        }
+        syncLogger.info(`Found ${sections.length} sections`);
+        const results = await syncAll(sections, {
+          verbose: options.debug ?? false,
+          updateExisting: true
+        });
+        const totalCreated = results.reduce((sum, r) => sum + r.created, 0);
+        const totalUpdated = results.reduce((sum, r) => sum + r.updated, 0);
+        const totalErrors = results.reduce((sum, r) => sum + r.errors.length, 0);
+        if (options.debug || totalCreated > 0 || totalUpdated > 0) {
+          syncLogger.info("Label sync completed", {
+            sections: results.length,
+            created: totalCreated,
+            updated: totalUpdated,
+            errors: totalErrors
+          });
+        }
+        if (totalErrors > 0) {
+          results.forEach((result) => {
+            result.errors.forEach((error) => {
+              syncLogger.error(`[${result.section}] ${error.key}: ${error.error}`);
+            });
+          });
+        }
+      } catch (error) {
+        const err = error instanceof Error ? error : new Error(String(error));
+        syncLogger.error("Label sync failed", err);
+        throw err;
+      }
+    }
+  };
+}
+async function attemptIncrementalSync(options) {
+  const { cwd, labelsPath, changedFilePath, debug } = options;
+  try {
+    const fullPath = join2(cwd, changedFilePath);
+    if (!existsSync2(fullPath)) {
+      return false;
+    }
+    const relativePath = relative(labelsPath, fullPath);
+    const parts = relativePath.split("/");
+    if (parts.length < 2) {
+      return false;
+    }
+    const sectionName = parts[0];
+    if (debug) {
+      syncLogger.info("Attempting incremental sync", {
+        section: sectionName,
+        file: changedFilePath
+      });
+    }
+    const sectionPath = join2(labelsPath, sectionName);
+    const labels = loadSectionLabels2(sectionPath);
+    if (Object.keys(labels).length === 0) {
+      if (debug) {
+        syncLogger.warn("Section has no valid labels");
+      }
+      return false;
+    }
+    const result = await syncSection(
+      { section: sectionName, labels },
+      { verbose: debug, updateExisting: true }
+    );
+    if (debug || result.created > 0 || result.updated > 0) {
+      syncLogger.info(`[${sectionName}] Incremental sync completed`, {
+        created: result.created,
+        updated: result.updated,
+        unchanged: result.unchanged,
+        errors: result.errors.length
+      });
+    }
+    if (result.errors.length > 0) {
+      result.errors.forEach((error) => {
+        syncLogger.error(`[${sectionName}] ${error.key}: ${error.error}`);
+      });
+    }
+    return true;
+  } catch (error) {
+    if (debug) {
+      const err = error instanceof Error ? error : new Error(String(error));
+      syncLogger.warn("Incremental sync failed", err);
+    }
+    return false;
+  }
+}
+function loadSectionLabels2(sectionPath) {
+  const labels = {};
+  if (!existsSync2(sectionPath)) {
+    return labels;
+  }
+  try {
+    const entries = readdirSync2(sectionPath);
+    for (const entry of entries) {
+      const filePath = join2(sectionPath, entry);
+      const stat = statSync2(filePath);
+      if (stat.isFile() && extname2(entry) === ".json") {
+        try {
+          const content = readFileSync2(filePath, "utf-8");
+          const data = JSON.parse(content);
+          if (typeof data === "object" && data !== null) {
+            Object.assign(labels, data);
+          }
+        } catch (error) {
+          const err = error instanceof Error ? error : new Error(String(error));
+          syncLogger.warn(`Failed to parse ${filePath}`, err);
+        }
+      }
+    }
+  } catch (error) {
+    const err = error instanceof Error ? error : new Error(String(error));
+    syncLogger.warn(`Failed to read section ${sectionPath}`, err);
+  }
+  return labels;
+}
+
+// src/server/generators/index.ts
+var generators = {
+  "label-sync": createLabelSyncGenerator
+};
+export {
+  createLabelSyncGenerator,
+  generators
+};
+//# sourceMappingURL=index.js.map