@asagiri-design/labels-config 0.2.2

package/dist/github/index.d.ts

@@ -0,0 +1,113 @@
+import { L as LabelConfig } from '../types-CkwsO1Iu.js';
+
+/**
+ * GitHub CLI Client
+ * Wrapper around gh CLI for label operations
+ * No token required - uses gh CLI authentication
+ */
+
+interface GitHubClientOptions {
+    /** Repository owner */
+    owner: string;
+    /** Repository name */
+    repo: string;
+}
+interface GitHubLabel {
+    /** Label name */
+    name: string;
+    /** Hex color (without #) */
+    color: string;
+    /** Label description */
+    description?: string;
+}
+declare class GitHubClient {
+    private owner;
+    private repo;
+    private repoPath;
+    constructor(options: GitHubClientOptions);
+    /**
+     * Execute gh CLI command
+     */
+    private exec;
+    /**
+     * Fetch all labels from repository
+     */
+    fetchLabels(): Promise<GitHubLabel[]>;
+    /**
+     * Create a new label
+     */
+    createLabel(label: LabelConfig): Promise<GitHubLabel>;
+    /**
+     * Update an existing label
+     */
+    updateLabel(currentName: string, label: Partial<LabelConfig>): Promise<GitHubLabel>;
+    /**
+     * Delete a label
+     */
+    deleteLabel(name: string): Promise<void>;
+    /**
+     * Check if label exists
+     */
+    hasLabel(name: string): Promise<boolean>;
+}
+
+/**
+ * GitHub Label Synchronization
+ * Syncs local labels to GitHub repositories
+ */
+
+interface GitHubSyncOptions extends GitHubClientOptions {
+    /** Dry run mode - don't make actual changes */
+    dryRun?: boolean;
+    /** Delete labels on GitHub that don't exist locally */
+    deleteExtra?: boolean;
+    /** Verbose logging */
+    verbose?: boolean;
+}
+interface SyncResult {
+    /** Labels created */
+    created: LabelConfig[];
+    /** Labels updated */
+    updated: LabelConfig[];
+    /** Labels deleted */
+    deleted: string[];
+    /** Labels unchanged */
+    unchanged: LabelConfig[];
+    /** Errors during sync */
+    errors: Array<{
+        name: string;
+        error: string;
+    }>;
+}
+declare class GitHubLabelSync {
+    private static readonly BATCH_SIZE;
+    private client;
+    private options;
+    constructor(options: GitHubSyncOptions);
+    /**
+     * Log message if verbose mode is enabled
+     */
+    private log;
+    /**
+     * Sync labels to GitHub repository with batch operations for better performance
+     */
+    syncLabels(localLabels: LabelConfig[]): Promise<SyncResult>;
+    /**
+     * Check if label has changes
+     */
+    private hasChanges;
+    /**
+     * Fetch labels from GitHub
+     */
+    fetchLabels(): Promise<LabelConfig[]>;
+    /**
+     * Delete a single label
+     */
+    deleteLabel(name: string): Promise<void>;
+    /**
+     * Update a single label
+     */
+    updateLabel(name: string, updates: Partial<LabelConfig>): Promise<void>;
+}
+
+export { GitHubClient, type GitHubClientOptions, type GitHubLabel, GitHubLabelSync, type GitHubSyncOptions };

package/dist/github/index.js

@@ -0,0 +1,310 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+// src/github/index.ts
+var github_exports = {};
+__export(github_exports, {
+  GitHubClient: () => GitHubClient,
+  GitHubLabelSync: () => GitHubLabelSync
+});
+module.exports = __toCommonJS(github_exports);
+
+// 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 (error) {
+      throw new Error(`gh CLI command failed: ${error.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 (error) {
+      throw new Error(`Failed to fetch labels from ${this.repoPath}: ${error}`);
+    }
+  }
+  /**
+   * 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 (error) {
+      throw new Error(`Failed to create label "${label.name}": ${error}`);
+    }
+  }
+  /**
+   * 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 (error) {
+      throw new Error(`Failed to update label "${currentName}": ${error}`);
+    }
+  }
+  /**
+   * Delete a label
+   */
+  async deleteLabel(name) {
+    try {
+      const escapedName = name.replace(/"/g, '\\"');
+      this.exec(`gh label delete "${escapedName}" --repo ${this.repoPath} --yes`);
+    } catch (error) {
+      throw new Error(`Failed to delete label "${name}": ${error}`);
+    }
+  }
+  /**
+   * Check if label exists
+   */
+  async hasLabel(name) {
+    try {
+      const labels = await this.fetchLabels();
+      return labels.some((label) => label.name.toLowerCase() === name.toLowerCase());
+    } catch (error) {
+      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 (error) {
+            result.errors.push({
+              name: label.name,
+              error: error instanceof Error ? error.message : String(error)
+            });
+            this.log(`Error creating label "${label.name}": ${error}`);
+          }
+        });
+        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 (error) {
+            result.errors.push({
+              name: updated.name,
+              error: error instanceof Error ? error.message : String(error)
+            });
+            this.log(`Error updating label "${updated.name}": ${error}`);
+          }
+        });
+        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 (error) {
+            result.errors.push({
+              name,
+              error: error instanceof Error ? error.message : String(error)
+            });
+            this.log(`Error deleting label "${name}": ${error}`);
+          }
+        });
+        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;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  GitHubClient,
+  GitHubLabelSync
+});

package/dist/github/index.mjs

@@ -0,0 +1,9 @@
+import {
+  GitHubClient,
+  GitHubLabelSync
+} from "../chunk-4ZUJQMV7.mjs";
+import "../chunk-QZ7TP4HQ.mjs";
+export {
+  GitHubClient,
+  GitHubLabelSync
+};