@asagiri-design/labels-config 0.2.2

package/dist/cli.js

@@ -0,0 +1,1417 @@
+#!/usr/bin/env node
+"use strict";
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+// src/cli.ts
+var import_fs = require("fs");
+
+// src/types.ts
+function isCategorized(labels) {
+  return Array.isArray(labels) && labels.length > 0 && "category" in labels[0] && "labels" in labels[0];
+}
+function flattenLabels(labels) {
+  if (isCategorized(labels)) {
+    return labels.flatMap((cat) => cat.labels);
+  }
+  return labels;
+}
+
+// src/validation.ts
+var import_zod = require("zod");
+
+// src/utils/color.ts
+function normalizeHexColor(input) {
+  const color = input.toLowerCase();
+  if (color.length === 3) {
+    return color.split("").map((c) => c + c).join("");
+  }
+  return color;
+}
+
+// src/validation.ts
+var hexColorSchema = import_zod.z.string().regex(/^[0-9a-fA-F]{6}$|^[0-9a-fA-F]{3}$/, "Invalid hex color format").transform((color) => normalizeHexColor(color));
+var labelConfigSchema = import_zod.z.object({
+  name: import_zod.z.string().min(1, "Label name is required").max(50, "Label name must be 50 characters or less").regex(
+    /^[a-zA-Z0-9\-\s\/\u3040-\u309F\u30A0-\u30FF\u4E00-\u9FFF]+$/,
+    "Label name contains invalid characters"
+  ),
+  color: hexColorSchema,
+  description: import_zod.z.string().min(1, "Description is required").max(200, "Description must be 200 characters or less")
+});
+var labelCategorySchema = import_zod.z.object({
+  category: import_zod.z.string().min(1, "Category name is required").max(50, "Category name must be 50 characters or less"),
+  labels: import_zod.z.array(labelConfigSchema)
+});
+var labelRegistrySchema = import_zod.z.object({
+  version: import_zod.z.string(),
+  timestamp: import_zod.z.string().datetime().optional(),
+  labels: import_zod.z.union([
+    import_zod.z.array(labelConfigSchema),
+    import_zod.z.array(labelCategorySchema)
+  ]),
+  metadata: import_zod.z.record(import_zod.z.unknown()).optional()
+});
+function validateLabels(labels) {
+  const schema = import_zod.z.array(labelConfigSchema);
+  return schema.parse(labels);
+}
+function findDuplicateStrings(values) {
+  const seen = /* @__PURE__ */ new Map();
+  const duplicates = /* @__PURE__ */ new Set();
+  for (const value of values) {
+    const count = seen.get(value) || 0;
+    seen.set(value, count + 1);
+    if (count === 1) {
+      duplicates.add(value);
+    }
+  }
+  return Array.from(duplicates);
+}
+function checkDuplicateNames(labels) {
+  const names = labels.map((label) => label.name);
+  return findDuplicateStrings(names);
+}
+function checkDuplicateColors(labels) {
+  const colors2 = labels.map((label) => normalizeHexColor(label.color));
+  return findDuplicateStrings(colors2);
+}
+function validateWithDetails(labels) {
+  try {
+    const parsed = validateLabels(labels);
+    const duplicateNames = checkDuplicateNames(parsed);
+    const duplicateColors = checkDuplicateColors(parsed);
+    return {
+      valid: duplicateNames.length === 0 && duplicateColors.length === 0,
+      labels: parsed,
+      errors: {
+        duplicateNames,
+        duplicateColors
+      }
+    };
+  } catch (error2) {
+    if (error2 instanceof import_zod.z.ZodError) {
+      return {
+        valid: false,
+        labels: [],
+        errors: {
+          validationErrors: error2.errors
+        }
+      };
+    }
+    throw error2;
+  }
+}
+
+// src/manager.ts
+var LabelManager = class {
+  constructor(options = {}) {
+    __publicField(this, "labels", /* @__PURE__ */ new Map());
+    __publicField(this, "strict", false);
+    this.strict = options.strict ?? false;
+    if (options.labels) {
+      this.loadLabels(options.labels);
+    }
+  }
+  /**
+   * Load labels from array
+   */
+  loadLabels(labels) {
+    const validation = validateWithDetails(labels);
+    if (!validation.valid && this.strict) {
+      throw new Error(`Label validation failed: ${JSON.stringify(validation.errors)}`);
+    }
+    this.labels.clear();
+    validation.labels.forEach((label) => {
+      this.labels.set(label.name.toLowerCase(), label);
+    });
+  }
+  /**
+   * Load labels from registry object
+   */
+  loadRegistry(registry) {
+    const labels = flattenLabels(registry.labels);
+    this.loadLabels(labels);
+  }
+  /**
+   * Add a single label
+   */
+  addLabel(label) {
+    const validation = validateLabels([label]);
+    const newLabel = validation[0];
+    if (this.labels.has(newLabel.name.toLowerCase())) {
+      throw new Error(`Label "${newLabel.name}" already exists`);
+    }
+    this.labels.set(newLabel.name.toLowerCase(), newLabel);
+  }
+  /**
+   * Update an existing label
+   */
+  updateLabel(name, updates) {
+    const key = name.toLowerCase();
+    const existing = this.labels.get(key);
+    if (!existing) {
+      throw new Error(`Label "${name}" not found`);
+    }
+    const updated = { ...existing, ...updates };
+    const validation = validateLabels([updated]);
+    this.labels.set(key, validation[0]);
+  }
+  /**
+   * Remove a label
+   */
+  removeLabel(name) {
+    this.labels.delete(name.toLowerCase());
+  }
+  /**
+   * Get a label by name
+   */
+  getLabel(name) {
+    return this.labels.get(name.toLowerCase());
+  }
+  /**
+   * Check if label exists
+   */
+  hasLabel(name) {
+    return this.labels.has(name.toLowerCase());
+  }
+  /**
+   * Get all labels
+   */
+  getAllLabels() {
+    return Array.from(this.labels.values());
+  }
+  /**
+   * Get labels count
+   */
+  count() {
+    return this.labels.size;
+  }
+  /**
+   * Export labels as array
+   */
+  export() {
+    return this.getAllLabels();
+  }
+  /**
+   * Export as registry object
+   */
+  exportRegistry(version = "1.0.0", metadata) {
+    return {
+      version,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      labels: this.getAllLabels(),
+      metadata
+    };
+  }
+  /**
+   * Search labels by name or description
+   */
+  search(query) {
+    const lowerQuery = query.toLowerCase();
+    return this.getAllLabels().filter(
+      (label) => label.name.toLowerCase().includes(lowerQuery) || label.description.toLowerCase().includes(lowerQuery)
+    );
+  }
+  /**
+   * Find labels by color
+   */
+  findByColor(color) {
+    const normalizedColor = color.toLowerCase();
+    return this.getAllLabels().filter((label) => label.color.toLowerCase() === normalizedColor);
+  }
+  /**
+   * Clear all labels
+   */
+  clear() {
+    this.labels.clear();
+  }
+  /**
+   * Validate current state
+   */
+  validate() {
+    const labels = this.getAllLabels();
+    const duplicates = checkDuplicateNames(labels);
+    return {
+      valid: duplicates.length === 0,
+      duplicates
+    };
+  }
+};
+
+// src/config/loader.ts
+var ConfigLoader = class {
+  constructor(options = {}) {
+    __publicField(this, "strict");
+    this.strict = options.strict ?? true;
+  }
+  /**
+   * Load labels from JSON object
+   */
+  loadFromJSON(data) {
+    if (typeof data === "object" && data !== null && "labels" in data && Array.isArray(data.labels)) {
+      const labels = data.labels;
+      if (labels.length > 0 && "category" in labels[0]) {
+        return labels.flatMap((cat) => cat.labels);
+      }
+      return validateLabels(labels);
+    }
+    return validateLabels(data);
+  }
+  /**
+   * Load from JSON string
+   */
+  loadFromString(jsonString) {
+    try {
+      const data = JSON.parse(jsonString);
+      return this.loadFromJSON(data);
+    } catch (error2) {
+      throw new Error(
+        `Failed to parse JSON: ${error2 instanceof Error ? error2.message : String(error2)}`
+      );
+    }
+  }
+  /**
+   * Load from registry object
+   */
+  loadRegistry(registry) {
+    return this.loadFromJSON({ labels: registry.labels });
+  }
+};
+
+// src/github/client.ts
+var import_child_process = require("child_process");
+var GitHubClient = class {
+  constructor(options) {
+    __publicField(this, "owner");
+    __publicField(this, "repo");
+    __publicField(this, "repoPath");
+    this.owner = options.owner;
+    this.repo = options.repo;
+    this.repoPath = `${this.owner}/${this.repo}`;
+  }
+  /**
+   * Execute gh CLI command
+   */
+  exec(command) {
+    try {
+      return (0, import_child_process.execSync)(command, {
+        encoding: "utf-8",
+        stdio: ["pipe", "pipe", "pipe"]
+      }).trim();
+    } catch (error2) {
+      throw new Error(`gh CLI command failed: ${error2.message}`);
+    }
+  }
+  /**
+   * Fetch all labels from repository
+   */
+  async fetchLabels() {
+    try {
+      const output = this.exec(
+        `gh label list --repo ${this.repoPath} --json name,color,description --limit 1000`
+      );
+      if (!output) {
+        return [];
+      }
+      const labels = JSON.parse(output);
+      return labels.map((label) => ({
+        name: label.name,
+        color: label.color,
+        description: label.description || ""
+      }));
+    } catch (error2) {
+      throw new Error(`Failed to fetch labels from ${this.repoPath}: ${error2}`);
+    }
+  }
+  /**
+   * Create a new label
+   */
+  async createLabel(label) {
+    try {
+      const name = label.name.replace(/"/g, '\\"');
+      const description = label.description.replace(/"/g, '\\"');
+      const color = label.color.replace("#", "");
+      this.exec(
+        `gh label create "${name}" --color "${color}" --description "${description}" --repo ${this.repoPath}`
+      );
+      return {
+        name: label.name,
+        color: label.color,
+        description: label.description
+      };
+    } catch (error2) {
+      throw new Error(`Failed to create label "${label.name}": ${error2}`);
+    }
+  }
+  /**
+   * Update an existing label
+   */
+  async updateLabel(currentName, label) {
+    try {
+      const escapedCurrentName = currentName.replace(/"/g, '\\"');
+      const args = [];
+      if (label.name && label.name !== currentName) {
+        args.push(`--name "${label.name.replace(/"/g, '\\"')}"`);
+      }
+      if (label.color) {
+        args.push(`--color "${label.color.replace("#", "")}"`);
+      }
+      if (label.description !== void 0) {
+        args.push(`--description "${label.description.replace(/"/g, '\\"')}"`);
+      }
+      if (args.length === 0) {
+        return {
+          name: currentName,
+          color: label.color || "",
+          description: label.description || ""
+        };
+      }
+      this.exec(
+        `gh label edit "${escapedCurrentName}" ${args.join(" ")} --repo ${this.repoPath}`
+      );
+      return {
+        name: label.name || currentName,
+        color: label.color || "",
+        description: label.description || ""
+      };
+    } catch (error2) {
+      throw new Error(`Failed to update label "${currentName}": ${error2}`);
+    }
+  }
+  /**
+   * Delete a label
+   */
+  async deleteLabel(name) {
+    try {
+      const escapedName = name.replace(/"/g, '\\"');
+      this.exec(`gh label delete "${escapedName}" --repo ${this.repoPath} --yes`);
+    } catch (error2) {
+      throw new Error(`Failed to delete label "${name}": ${error2}`);
+    }
+  }
+  /**
+   * Check if label exists
+   */
+  async hasLabel(name) {
+    try {
+      const labels = await this.fetchLabels();
+      return labels.some((label) => label.name.toLowerCase() === name.toLowerCase());
+    } catch (error2) {
+      return false;
+    }
+  }
+};
+
+// src/github/sync.ts
+var _GitHubLabelSync = class _GitHubLabelSync {
+  constructor(options) {
+    __publicField(this, "client");
+    __publicField(this, "options");
+    this.client = new GitHubClient(options);
+    this.options = options;
+  }
+  /**
+   * Log message if verbose mode is enabled
+   */
+  log(message) {
+    if (this.options.verbose) {
+      console.log(`[labels-config] ${message}`);
+    }
+  }
+  /**
+   * Sync labels to GitHub repository with batch operations for better performance
+   */
+  async syncLabels(localLabels) {
+    this.log("Fetching remote labels...");
+    const remoteLabels = await this.client.fetchLabels();
+    const result = {
+      created: [],
+      updated: [],
+      deleted: [],
+      unchanged: [],
+      errors: []
+    };
+    const remoteLabelMap = new Map(remoteLabels.map((label) => [label.name.toLowerCase(), label]));
+    const localLabelMap = new Map(localLabels.map((label) => [label.name.toLowerCase(), label]));
+    const toCreate = [];
+    const toUpdate = [];
+    const toDelete = [];
+    for (const label of localLabels) {
+      const remoteLabel = remoteLabelMap.get(label.name.toLowerCase());
+      if (!remoteLabel) {
+        toCreate.push(label);
+      } else if (this.hasChanges(label, remoteLabel)) {
+        toUpdate.push({ current: remoteLabel.name, updated: label });
+      } else {
+        result.unchanged.push(label);
+        this.log(`Unchanged label: ${label.name}`);
+      }
+    }
+    if (this.options.deleteExtra) {
+      for (const remoteLabel of remoteLabels) {
+        if (!localLabelMap.has(remoteLabel.name.toLowerCase())) {
+          toDelete.push(remoteLabel.name);
+        }
+      }
+    }
+    if (!this.options.dryRun) {
+      for (let i = 0; i < toCreate.length; i += _GitHubLabelSync.BATCH_SIZE) {
+        const batch = toCreate.slice(i, i + _GitHubLabelSync.BATCH_SIZE);
+        const promises = batch.map(async (label) => {
+          try {
+            await this.client.createLabel(label);
+            result.created.push(label);
+            this.log(`Created label: ${label.name}`);
+          } catch (error2) {
+            result.errors.push({
+              name: label.name,
+              error: error2 instanceof Error ? error2.message : String(error2)
+            });
+            this.log(`Error creating label "${label.name}": ${error2}`);
+          }
+        });
+        await Promise.all(promises);
+      }
+      for (let i = 0; i < toUpdate.length; i += _GitHubLabelSync.BATCH_SIZE) {
+        const batch = toUpdate.slice(i, i + _GitHubLabelSync.BATCH_SIZE);
+        const promises = batch.map(async ({ current, updated }) => {
+          try {
+            await this.client.updateLabel(current, updated);
+            result.updated.push(updated);
+            this.log(`Updated label: ${updated.name}`);
+          } catch (error2) {
+            result.errors.push({
+              name: updated.name,
+              error: error2 instanceof Error ? error2.message : String(error2)
+            });
+            this.log(`Error updating label "${updated.name}": ${error2}`);
+          }
+        });
+        await Promise.all(promises);
+      }
+      for (let i = 0; i < toDelete.length; i += _GitHubLabelSync.BATCH_SIZE) {
+        const batch = toDelete.slice(i, i + _GitHubLabelSync.BATCH_SIZE);
+        const promises = batch.map(async (name) => {
+          try {
+            await this.client.deleteLabel(name);
+            result.deleted.push(name);
+            this.log(`Deleted label: ${name}`);
+          } catch (error2) {
+            result.errors.push({
+              name,
+              error: error2 instanceof Error ? error2.message : String(error2)
+            });
+            this.log(`Error deleting label "${name}": ${error2}`);
+          }
+        });
+        await Promise.all(promises);
+      }
+    } else {
+      result.created.push(...toCreate);
+      result.updated.push(...toUpdate.map((op) => op.updated));
+      result.deleted.push(...toDelete);
+      toCreate.forEach((label) => this.log(`[DRY RUN] Would create label: ${label.name}`));
+      toUpdate.forEach(({ updated }) => this.log(`[DRY RUN] Would update label: ${updated.name}`));
+      toDelete.forEach((name) => this.log(`[DRY RUN] Would delete label: ${name}`));
+    }
+    return result;
+  }
+  /**
+   * Check if label has changes
+   */
+  hasChanges(local, remote) {
+    return local.color.toLowerCase() !== remote.color.toLowerCase() || local.description !== (remote.description || "");
+  }
+  /**
+   * Fetch labels from GitHub
+   */
+  async fetchLabels() {
+    const labels = await this.client.fetchLabels();
+    return labels.map((label) => ({
+      name: label.name,
+      color: label.color,
+      description: label.description || ""
+    }));
+  }
+  /**
+   * Delete a single label
+   */
+  async deleteLabel(name) {
+    if (!this.options.dryRun) {
+      await this.client.deleteLabel(name);
+    }
+    this.log(`Deleted label: ${name}`);
+  }
+  /**
+   * Update a single label
+   */
+  async updateLabel(name, updates) {
+    if (!this.options.dryRun) {
+      await this.client.updateLabel(name, updates);
+    }
+    this.log(`Updated label: ${name}`);
+  }
+};
+__publicField(_GitHubLabelSync, "BATCH_SIZE", 5);
+var GitHubLabelSync = _GitHubLabelSync;
+
+// src/config/templates.ts
+var MINIMAL_TEMPLATE = [
+  {
+    name: "bug",
+    color: "ff0000",
+    description: "Something is broken"
+  },
+  {
+    name: "feature",
+    color: "00ff00",
+    description: "New feature or request"
+  },
+  {
+    name: "documentation",
+    color: "0000ff",
+    description: "Improvements or additions to documentation"
+  }
+];
+var createLabels = (labels) => labels;
+var GITHUB_STANDARD_TEMPLATE = createLabels([
+  {
+    name: "bug",
+    color: "d73a4a",
+    description: "Something is broken"
+  },
+  {
+    name: "documentation",
+    color: "0075ca",
+    description: "Improvements or additions to documentation"
+  },
+  {
+    name: "duplicate",
+    color: "cfd3d7",
+    description: "This issue or pull request already exists"
+  },
+  {
+    name: "enhancement",
+    color: "a2eeef",
+    description: "New feature or request"
+  },
+  {
+    name: "good first issue",
+    color: "7057ff",
+    description: "Good for newcomers"
+  },
+  {
+    name: "help wanted",
+    color: "008672",
+    description: "Extra attention is needed"
+  },
+  {
+    name: "invalid",
+    color: "e4e669",
+    description: "This does not seem right"
+  },
+  {
+    name: "question",
+    color: "d876e3",
+    description: "Further information is requested"
+  },
+  {
+    name: "wontfix",
+    color: "ffffff",
+    description: "This will not be worked on"
+  }
+]);
+var PROD_EN_TEMPLATE = createLabels([
+  {
+    name: "API",
+    color: "ffb300",
+    description: "API integration and external services"
+  },
+  {
+    name: "BFF",
+    color: "7057ff",
+    description: "Backend for Frontend integration"
+  },
+  {
+    name: "CI/CD",
+    color: "00ced1",
+    description: "CI/CD and automation"
+  },
+  {
+    name: "Component",
+    color: "008672",
+    description: "Component addition and updates"
+  },
+  {
+    name: "Documentation",
+    color: "332412",
+    description: "Documentation additions and updates"
+  },
+  {
+    name: "Hotfix",
+    color: "ff6347",
+    description: "Emergency fixes and hotfixes"
+  },
+  {
+    name: "Refactoring",
+    color: "a9a9a9",
+    description: "Code refactoring and performance optimization"
+  },
+  {
+    name: "Testing",
+    color: "08a4d6",
+    description: "Testing, E2E, and unit tests"
+  },
+  {
+    name: "Type Definition",
+    color: "e91e63",
+    description: "TypeScript type definitions and type safety"
+  },
+  {
+    name: "Design",
+    color: "d876e3",
+    description: "UI/UX design"
+  },
+  {
+    name: "Specification",
+    color: "d93f0b",
+    description: "Specification changes"
+  },
+  {
+    name: "Feature",
+    color: "b3fa11",
+    description: "New feature addition"
+  },
+  {
+    name: "Environment",
+    color: "c5def5",
+    description: "Development environment and package updates"
+  },
+  {
+    name: "Page",
+    color: "16c9f5",
+    description: "Page additions and updates"
+  }
+]);
+var PROD_JA_TEMPLATE = createLabels([
+  {
+    name: "API\u9023\u643A",
+    color: "ffb300",
+    description: "API\u30FB\u5916\u90E8\u30B5\u30FC\u30D3\u30B9\u9023\u643A"
+  },
+  {
+    name: "BFF",
+    color: "7057ff",
+    description: "BFF\u30FB\u30D0\u30C3\u30AF\u30A8\u30F3\u30C9\u9023\u643A"
+  },
+  {
+    name: "CI/CD",
+    color: "00ced1",
+    description: "CI/CD\u30FB\u81EA\u52D5\u5316"
+  },
+  {
+    name: "\u30B3\u30F3\u30DD\u30FC\u30CD\u30F3\u30C8",
+    color: "008672",
+    description: "\u30B3\u30F3\u30DD\u30FC\u30CD\u30F3\u30C8\u306E\u8FFD\u52A0\u30FB\u66F4\u65B0"
+  },
+  {
+    name: "\u30C9\u30AD\u30E5\u30E1\u30F3\u30C8",
+    color: "332412",
+    description: "\u30C9\u30AD\u30E5\u30E1\u30F3\u30C8\u306E\u8FFD\u52A0\u30FB\u66F4\u65B0"
+  },
+  {
+    name: "\u7DCA\u6025\u5BFE\u5FDC",
+    color: "ff6347",
+    description: "\u7DCA\u6025\u4FEE\u6B63\u30FBHotfix"
+  },
+  {
+    name: "\u30EA\u30D5\u30A1\u30AF\u30BF",
+    color: "a9a9a9",
+    description: "\u30EA\u30D5\u30A1\u30AF\u30BF\u30EA\u30F3\u30B0\u30FB\u30D1\u30D5\u30A9\u30FC\u30DE\u30F3\u30B9\u6700\u9069\u5316\u30FB\u30B3\u30FC\u30C9\u6574\u7406"
+  },
+  {
+    name: "\u30C6\u30B9\u30C8",
+    color: "08a4d6",
+    description: "\u30C6\u30B9\u30C8\u30FBE2E\u30FB\u30E6\u30CB\u30C3\u30C8\u30C6\u30B9\u30C8"
+  },
+  {
+    name: "\u578B\u5B9A\u7FA9",
+    color: "e91e63",
+    description: "TypeScript\u578B\u5B9A\u7FA9\u30FB\u578B\u5B89\u5168\u6027"
+  },
+  {
+    name: "\u30C7\u30B6\u30A4\u30F3",
+    color: "d876e3",
+    description: "UIUX\u30C7\u30B6\u30A4\u30F3"
+  },
+  {
+    name: "\u4ED5\u69D8\u5909\u66F4",
+    color: "d93f0b",
+    description: "\u4ED5\u69D8\u5909\u66F4"
+  },
+  {
+    name: "\u6A5F\u80FD\u8FFD\u52A0",
+    color: "b3fa11",
+    description: "\u6A5F\u80FD\u8FFD\u52A0"
+  },
+  {
+    name: "\u74B0\u5883\u69CB\u7BC9",
+    color: "c5def5",
+    description: "\u958B\u767A\u74B0\u5883\u30FB\u30D1\u30C3\u30B1\u30FC\u30B8\u306E\u8FFD\u52A0\u30FB\u5909\u66F4\u30FB\u66F4\u65B0"
+  },
+  {
+    name: "\u753B\u9762\u8FFD\u52A0",
+    color: "16c9f5",
+    description: "\u753B\u9762\u306E\u8FFD\u52A0\u30FB\u66F4\u65B0"
+  }
+]);
+var PROD_TEMPLATE = PROD_JA_TEMPLATE;
+var REACT_TEMPLATE = createLabels([
+  {
+    name: "component",
+    color: "61dafb",
+    description: "React component development"
+  },
+  {
+    name: "hook",
+    color: "20232a",
+    description: "Custom hooks implementation"
+  },
+  {
+    name: "state-management",
+    color: "764abc",
+    description: "Redux, Zustand, Context API"
+  },
+  {
+    name: "performance",
+    color: "ffc107",
+    description: "Performance optimization, memoization"
+  },
+  {
+    name: "typescript",
+    color: "3178c6",
+    description: "TypeScript types and interfaces"
+  },
+  {
+    name: "styling",
+    color: "ff69b4",
+    description: "CSS-in-JS, Tailwind, styled-components"
+  },
+  {
+    name: "testing",
+    color: "15c213",
+    description: "Unit tests, React Testing Library"
+  },
+  {
+    name: "bug",
+    color: "d73a4a",
+    description: "Bug fix required"
+  },
+  {
+    name: "refactor",
+    color: "fbca04",
+    description: "Code refactoring"
+  },
+  {
+    name: "accessibility",
+    color: "0e8a16",
+    description: "A11y improvements"
+  }
+]);
+var VUE_TEMPLATE = createLabels([
+  {
+    name: "component",
+    color: "42b883",
+    description: "Vue component development"
+  },
+  {
+    name: "composable",
+    color: "35495e",
+    description: "Composition API, composables"
+  },
+  {
+    name: "pinia",
+    color: "ffd859",
+    description: "Pinia state management"
+  },
+  {
+    name: "vue-router",
+    color: "3ba57a",
+    description: "Vue Router navigation"
+  },
+  {
+    name: "typescript",
+    color: "3178c6",
+    description: "TypeScript integration"
+  },
+  {
+    name: "styling",
+    color: "ff69b4",
+    description: "Scoped CSS, CSS modules"
+  },
+  {
+    name: "testing",
+    color: "15c213",
+    description: "Vitest, Vue Test Utils"
+  },
+  {
+    name: "bug",
+    color: "d73a4a",
+    description: "Bug fix required"
+  },
+  {
+    name: "performance",
+    color: "ffc107",
+    description: "Performance optimization"
+  },
+  {
+    name: "accessibility",
+    color: "0e8a16",
+    description: "A11y improvements"
+  }
+]);
+var FRONTEND_TEMPLATE = createLabels([
+  {
+    name: "feature",
+    color: "0e8a16",
+    description: "New feature implementation"
+  },
+  {
+    name: "bug",
+    color: "d73a4a",
+    description: "Bug fix required"
+  },
+  {
+    name: "ui",
+    color: "ff69b4",
+    description: "UI/UX improvements"
+  },
+  {
+    name: "styling",
+    color: "c5def5",
+    description: "CSS, styling updates"
+  },
+  {
+    name: "responsive",
+    color: "1d76db",
+    description: "Responsive design, mobile support"
+  },
+  {
+    name: "performance",
+    color: "ffc107",
+    description: "Performance optimization"
+  },
+  {
+    name: "accessibility",
+    color: "0052cc",
+    description: "A11y improvements"
+  },
+  {
+    name: "testing",
+    color: "15c213",
+    description: "Testing, E2E, unit tests"
+  },
+  {
+    name: "dependencies",
+    color: "0366d6",
+    description: "Dependencies update"
+  },
+  {
+    name: "documentation",
+    color: "0075ca",
+    description: "Documentation updates"
+  },
+  {
+    name: "build",
+    color: "fbca04",
+    description: "Build system, bundler"
+  },
+  {
+    name: "seo",
+    color: "b60205",
+    description: "SEO optimization"
+  }
+]);
+var AGILE_TEMPLATE = createLabels([
+  {
+    name: "story",
+    color: "0e7490",
+    description: "User story"
+  },
+  {
+    name: "task",
+    color: "4c72a0",
+    description: "Implementation task"
+  },
+  {
+    name: "spike",
+    color: "ab47bc",
+    description: "Research and exploration"
+  },
+  {
+    name: "bug",
+    color: "d32f2f",
+    description: "Bug fix"
+  },
+  {
+    name: "debt",
+    color: "f57c00",
+    description: "Technical debt"
+  },
+  {
+    name: "blocked",
+    color: "616161",
+    description: "Blocked by another issue"
+  },
+  {
+    name: "priority:critical",
+    color: "ff0000",
+    description: "Critical priority"
+  },
+  {
+    name: "priority:high",
+    color: "ff9800",
+    description: "High priority"
+  },
+  {
+    name: "priority:medium",
+    color: "ffc107",
+    description: "Medium priority"
+  },
+  {
+    name: "priority:low",
+    color: "cddc39",
+    description: "Low priority"
+  }
+]);
+var CONFIG_TEMPLATES = {
+  minimal: MINIMAL_TEMPLATE,
+  github: GITHUB_STANDARD_TEMPLATE,
+  react: REACT_TEMPLATE,
+  vue: VUE_TEMPLATE,
+  frontend: FRONTEND_TEMPLATE,
+  "prod-en": PROD_EN_TEMPLATE,
+  "prod-ja": PROD_JA_TEMPLATE,
+  prod: PROD_TEMPLATE,
+  agile: AGILE_TEMPLATE
+};
+function listTemplates() {
+  return Object.keys(CONFIG_TEMPLATES);
+}
+
+// src/utils/args.ts
+function parseArgs(argv) {
+  const result = {
+    command: void 0,
+    flags: /* @__PURE__ */ new Set(),
+    options: /* @__PURE__ */ new Map(),
+    positional: []
+  };
+  let i = 0;
+  if (i < argv.length && !argv[i].startsWith("-")) {
+    result.command = argv[i];
+    i++;
+  }
+  while (i < argv.length) {
+    const arg = argv[i];
+    if (arg.startsWith("--")) {
+      const parts = arg.split("=", 2);
+      if (parts.length === 2) {
+        result.options.set(parts[0], parts[1]);
+        i++;
+      } else {
+        const nextArg = argv[i + 1];
+        if (!nextArg || nextArg.startsWith("-")) {
+          result.flags.add(arg);
+          i++;
+        } else {
+          result.options.set(arg, nextArg);
+          i += 2;
+        }
+      }
+    } else if (arg.startsWith("-")) {
+      result.flags.add(arg);
+      i++;
+    } else {
+      result.positional.push(arg);
+      i++;
+    }
+  }
+  return result;
+}
+function getRequiredOption(args, name, errorMessage) {
+  const value = args.options.get(name);
+  if (!value) {
+    throw new Error(errorMessage || `Missing required option: ${name}`);
+  }
+  return value;
+}
+function getOption(args, name, defaultValue) {
+  return args.options.get(name) || defaultValue;
+}
+function hasFlag(args, ...names) {
+  return names.some((name) => args.flags.has(name));
+}
+function getPositional(args, index) {
+  return args.positional[index];
+}
+
+// src/utils/ui.ts
+var colors = {
+  reset: "\x1B[0m",
+  bright: "\x1B[1m",
+  dim: "\x1B[2m",
+  // Foreground colors
+  red: "\x1B[31m",
+  green: "\x1B[32m",
+  yellow: "\x1B[33m",
+  blue: "\x1B[34m",
+  magenta: "\x1B[35m",
+  cyan: "\x1B[36m",
+  white: "\x1B[37m",
+  gray: "\x1B[90m",
+  // Background colors
+  bgRed: "\x1B[41m",
+  bgGreen: "\x1B[42m",
+  bgYellow: "\x1B[43m",
+  bgBlue: "\x1B[44m"
+};
+function supportsColor() {
+  if (process.env.NO_COLOR) {
+    return false;
+  }
+  if (process.env.FORCE_COLOR) {
+    return true;
+  }
+  if (!process.stdout.isTTY) {
+    return false;
+  }
+  if (process.platform === "win32") {
+    return true;
+  }
+  return true;
+}
+function colorize(text, color) {
+  if (!supportsColor()) {
+    return text;
+  }
+  return `${colors[color]}${text}${colors.reset}`;
+}
+function success(message) {
+  return colorize("\u2713", "green") + " " + message;
+}
+function error(message) {
+  return colorize("\u2717", "red") + " " + message;
+}
+function warning(message) {
+  return colorize("\u26A0", "yellow") + " " + message;
+}
+function info(message) {
+  return colorize("\u2139", "blue") + " " + message;
+}
+function header(text) {
+  return "\n" + colorize(text, "bright") + "\n" + "\u2500".repeat(Math.min(text.length, 50));
+}
+var Spinner = class {
+  constructor() {
+    __publicField(this, "frames", ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"]);
+    __publicField(this, "interval", null);
+    __publicField(this, "frameIndex", 0);
+    __publicField(this, "message", "");
+  }
+  start(message) {
+    this.message = message;
+    if (!process.stdout.isTTY || !supportsColor()) {
+      console.log(message + "...");
+      return;
+    }
+    this.interval = setInterval(() => {
+      const frame = this.frames[this.frameIndex];
+      process.stdout.write(`\r${colorize(frame, "cyan")} ${this.message}`);
+      this.frameIndex = (this.frameIndex + 1) % this.frames.length;
+    }, 80);
+  }
+  succeed(message) {
+    this.stop();
+    console.log(success(message || this.message));
+  }
+  fail(message) {
+    this.stop();
+    console.log(error(message || this.message));
+  }
+  warn(message) {
+    this.stop();
+    console.log(warning(message || this.message));
+  }
+  stop() {
+    if (this.interval) {
+      clearInterval(this.interval);
+      this.interval = null;
+      if (process.stdout.isTTY) {
+        process.stdout.write("\r\x1B[K");
+      }
+    }
+  }
+};
+
+// src/cli.ts
+var rawArgs = process.argv.slice(2);
+var parsedArgs = parseArgs(rawArgs);
+function printUsage() {
+  console.log(colorize("\nlabels-config", "bright") + " - Terminal-first GitHub label management\n");
+  console.log(header("Commands"));
+  console.log("  " + colorize("validate", "cyan") + " <file>           Validate label configuration file");
+  console.log("  " + colorize("sync", "cyan") + "                     Sync labels to GitHub repository");
+  console.log("  " + colorize("export", "cyan") + "                   Export labels from GitHub repository");
+  console.log("  " + colorize("init", "cyan") + " <template>         Initialize new configuration");
+  console.log("  " + colorize("help", "cyan") + "                     Show this help message");
+  console.log(header("Prerequisites"));
+  console.log("  " + info("gh CLI must be installed and authenticated"));
+  console.log("  Run: " + colorize("gh auth login", "yellow"));
+  console.log("  No GitHub token required - uses gh CLI authentication");
+  console.log(header("Options"));
+  console.log("  " + colorize("--owner", "green") + " <owner>         Repository owner (required for sync/export)");
+  console.log("  " + colorize("--repo", "green") + " <repo>          Repository name (required for sync/export)");
+  console.log("  " + colorize("--file", "green") + " <file>          Configuration file path");
+  console.log("  " + colorize("--dry-run", "green") + "              Dry run mode (don't make changes)");
+  console.log("  " + colorize("--delete-extra", "green") + "         Replace mode: delete labels not in config");
+  console.log("  " + colorize("--verbose", "green") + "              Verbose output");
+  console.log(header("Available Templates"));
+  console.log("  " + colorize("minimal", "magenta") + "                Basic 3-label set (bug, feature, documentation)");
+  console.log("  " + colorize("github", "magenta") + "                 GitHub standard labels");
+  console.log("  " + colorize("react", "magenta") + "                  React ecosystem (components, hooks, state)");
+  console.log("  " + colorize("vue", "magenta") + "                    Vue.js ecosystem (composables, Pinia, router)");
+  console.log("  " + colorize("frontend", "magenta") + "               General frontend development");
+  console.log("  " + colorize("prod-en", "magenta") + "                Production project (14 labels, English)");
+  console.log("  " + colorize("prod-ja", "magenta") + "                Production project (14 labels, Japanese)");
+  console.log("  " + colorize("prod", "magenta") + "                   Production project (alias for prod-ja)");
+  console.log("  " + colorize("agile", "magenta") + "                  Agile/Scrum workflow");
+  console.log(header("Examples"));
+  console.log("  # Validate configuration");
+  console.log("  " + colorize("labels-config validate ./labels.json", "gray"));
+  console.log("");
+  console.log("  # Initialize from template");
+  console.log("  " + colorize("labels-config init react --file ./labels.json", "gray"));
+  console.log("");
+  console.log("  # Sync labels (append mode)");
+  console.log("  " + colorize("labels-config sync --owner user --repo repo --file labels.json", "gray"));
+  console.log("");
+  console.log("  # Sync with dry run");
+  console.log("  " + colorize("labels-config sync --owner user --repo repo --file labels.json --dry-run", "gray"));
+  console.log("");
+}
+async function validateCommand() {
+  const file = getPositional(parsedArgs, 0);
+  if (!file) {
+    console.error(error("File path required"));
+    console.error("Usage: labels-config validate <file>");
+    process.exit(1);
+  }
+  const spinner = new Spinner();
+  try {
+    try {
+      await import_fs.promises.access(file);
+    } catch {
+      console.error(error(`File not found: ${file}`));
+      process.exit(1);
+    }
+    spinner.start(`Reading ${file}`);
+    const content = await import_fs.promises.readFile(file, "utf-8");
+    let data;
+    try {
+      data = JSON.parse(content);
+    } catch (err) {
+      spinner.fail(`Invalid JSON in file: ${file}`);
+      console.error(error(err instanceof Error ? err.message : String(err)));
+      process.exit(1);
+    }
+    spinner.stop();
+    spinner.start("Validating configuration");
+    const result = validateWithDetails(data);
+    spinner.stop();
+    console.log(info(`Validating: ${file}`));
+    console.log(info(`Total labels: ${result.labels.length}`));
+    if (result.valid) {
+      console.log(success("Configuration is valid!"));
+      return;
+    } else {
+      console.log(error("Validation errors found:"));
+      const errors = result.errors;
+      if (errors.duplicateNames && errors.duplicateNames.length > 0) {
+        console.log(colorize(`  \u2022 Duplicate names: ${errors.duplicateNames.join(", ")}`, "red"));
+      }
+      if (errors.duplicateColors && errors.duplicateColors.length > 0) {
+        console.log(colorize(`  \u2022 Duplicate colors: ${errors.duplicateColors.join(", ")}`, "red"));
+      }
+      if (errors.validationErrors && errors.validationErrors.length > 0) {
+        console.log(colorize("  \u2022 Validation errors:", "red"));
+        errors.validationErrors.forEach((err) => {
+          console.log(`    ${err.path.join(".")}: ${err.message}`);
+        });
+      }
+      process.exit(1);
+    }
+  } catch (err) {
+    spinner.fail("Validation failed");
+    console.error(error(err instanceof Error ? err.message : String(err)));
+    process.exit(1);
+  }
+}
+async function syncCommand() {
+  const spinner = new Spinner();
+  try {
+    const owner = getRequiredOption(parsedArgs, "--owner", "Error: --owner is required for sync command");
+    const repo = getRequiredOption(parsedArgs, "--repo", "Error: --repo is required for sync command");
+    const file = getRequiredOption(parsedArgs, "--file", "Error: --file is required for sync command");
+    const dryRun = hasFlag(parsedArgs, "--dry-run");
+    const deleteExtra = hasFlag(parsedArgs, "--delete-extra");
+    const verbose = hasFlag(parsedArgs, "--verbose");
+    try {
+      await import_fs.promises.access(file);
+    } catch {
+      console.error(error(`File not found: ${file}`));
+      process.exit(1);
+    }
+    spinner.start(`Loading labels from ${file}`);
+    const content = await import_fs.promises.readFile(file, "utf-8");
+    let labels;
+    try {
+      const loader = new ConfigLoader();
+      labels = loader.loadFromString(content);
+      spinner.succeed(`Loaded ${labels.length} labels`);
+    } catch (err) {
+      spinner.fail(`Failed to load labels from file: ${file}`);
+      console.error(error(err instanceof Error ? err.message : String(err)));
+      process.exit(1);
+    }
+    const sync = new GitHubLabelSync({
+      owner,
+      repo,
+      dryRun,
+      deleteExtra,
+      verbose
+    });
+    const modeText = dryRun ? colorize("[DRY RUN]", "yellow") : "";
+    console.log(`
+${modeText} ${info(`Syncing to ${owner}/${repo}`)}`);
+    if (deleteExtra) {
+      console.log(warning("Replace mode: Will delete labels not in config"));
+    }
+    spinner.start("Syncing labels");
+    const result = await sync.syncLabels(labels);
+    spinner.succeed("Sync complete");
+    console.log(header("Results"));
+    if (result.created.length > 0) {
+      console.log(success(`Created: ${result.created.length}`));
+      if (verbose) {
+        result.created.forEach((label) => console.log(`  \u2022 ${label.name}`));
+      }
+    }
+    if (result.updated.length > 0) {
+      console.log(info(`Updated: ${result.updated.length}`));
+      if (verbose) {
+        result.updated.forEach((label) => console.log(`  \u2022 ${label.name}`));
+      }
+    }
+    if (result.deleted.length > 0) {
+      console.log(warning(`Deleted: ${result.deleted.length}`));
+      if (verbose) {
+        result.deleted.forEach((name) => console.log(`  \u2022 ${name}`));
+      }
+    }
+    if (result.unchanged.length > 0) {
+      console.log(colorize(`Unchanged: ${result.unchanged.length}`, "gray"));
+    }
+    if (result.errors.length > 0) {
+      console.log(header("Errors"));
+      result.errors.forEach((err) => {
+        console.log(error(`${err.name}: ${err.error}`));
+      });
+      process.exit(1);
+    }
+  } catch (err) {
+    spinner.fail("Sync failed");
+    console.error(error(err instanceof Error ? err.message : String(err)));
+    process.exit(1);
+  }
+}
+async function exportCommand() {
+  const spinner = new Spinner();
+  try {
+    const owner = getRequiredOption(parsedArgs, "--owner", "Error: --owner is required for export command");
+    const repo = getRequiredOption(parsedArgs, "--repo", "Error: --repo is required for export command");
+    const file = getOption(parsedArgs, "--file") || "labels.json";
+    spinner.start(`Fetching labels from ${owner}/${repo}`);
+    const sync = new GitHubLabelSync({ owner, repo });
+    const labels = await sync.fetchLabels();
+    spinner.succeed(`Fetched ${labels.length} labels`);
+    spinner.start("Creating registry");
+    const manager = new LabelManager({ labels });
+    const registry = manager.exportRegistry("1.0.0", { source: `${owner}/${repo}` });
+    await import_fs.promises.writeFile(file, JSON.stringify(registry, null, 2));
+    spinner.succeed(`Exported to ${file}`);
+    console.log(success(`Successfully exported ${labels.length} labels`));
+  } catch (err) {
+    spinner.fail("Export failed");
+    console.error(error(err instanceof Error ? err.message : String(err)));
+    process.exit(1);
+  }
+}
+async function initCommand() {
+  const template = getPositional(parsedArgs, 0);
+  const file = getOption(parsedArgs, "--file") || "labels.json";
+  if (!template || !listTemplates().includes(template)) {
+    console.log(error(`Invalid template "${template || ""}"`));
+    console.log(info("Available templates: ") + listTemplates().map((t) => colorize(t, "magenta")).join(", "));
+    process.exit(1);
+  }
+  const spinner = new Spinner();
+  try {
+    spinner.start(`Creating configuration from "${template}" template`);
+    const labels = CONFIG_TEMPLATES[template];
+    const manager = new LabelManager({ labels });
+    const registry = manager.exportRegistry("1.0.0");
+    await import_fs.promises.writeFile(file, JSON.stringify(registry, null, 2));
+    spinner.succeed(`Created ${file}`);
+    console.log(success(`Initialized with ${labels.length} labels from "${template}" template`));
+    console.log(info("Next steps:"));
+    console.log(`  1. Review and edit: ${colorize(file, "cyan")}`);
+    console.log(`  2. Validate: ${colorize(`labels-config validate ${file}`, "gray")}`);
+    console.log(`  3. Sync to repo: ${colorize(`labels-config sync --owner <owner> --repo <repo> --file ${file}`, "gray")}`);
+  } catch (err) {
+    spinner.fail("Initialization failed");
+    console.error(error(err instanceof Error ? err.message : String(err)));
+    process.exit(1);
+  }
+}
+async function main() {
+  const command = parsedArgs.command;
+  if (!command || command === "help" || hasFlag(parsedArgs, "--help", "-h")) {
+    printUsage();
+    return;
+  }
+  switch (command) {
+    case "validate":
+      await validateCommand();
+      break;
+    case "sync":
+      await syncCommand();
+      break;
+    case "export":
+      await exportCommand();
+      break;
+    case "init":
+      await initCommand();
+      break;
+    default:
+      console.error(`Unknown command: ${command}`);
+      printUsage();
+      process.exit(1);
+  }
+}
+main().catch((error2) => {
+  console.error("Fatal error:", error2);
+  process.exit(1);
+});