@asagiri-design/labels-config 0.2.2 → 0.3.0

package/README.md

@@ -281,6 +281,66 @@ jobs:
 
 ---
 
+## 🔐 Security & Publishing
+
+### Automated npm Publishing with Trusted Publishers (OIDC)
+
+This package uses **npm Trusted Publishers (OIDC)** for secure, automated publishing. No long-lived tokens required!
+
+**Key Features:**
+- ✅ Zero token management - GitHub Actions authenticates automatically
+- ✅ Enhanced security - No risk of token leakage
+- ✅ Automatic provenance - Package authenticity verification
+- ✅ Auto-release on merge - Patch version published when merging to main
+
+### How It Works
+
+**Automatic Release (main branch):**
+```bash
+# When you merge to main, the system automatically:
+# 1. Bumps the patch version (e.g., 0.2.0 → 0.2.1)
+# 2. Builds the package
+# 3. Publishes to npm with provenance
+# 4. Pushes the version tag
+```
+
+**Manual Release:**
+Use GitHub Actions UI to trigger manual releases with custom version bumps:
+- Navigate to **Actions** → **Manual Release**
+- Choose version type: `patch` / `minor` / `major` / `prerelease`
+- Run the workflow
+
+**Skip Auto-Release:**
+Include `[skip ci]` or `[no release]` in your commit message:
+```bash
+git commit -m "docs: update README [skip ci]"
+```
+
+### Setup Required
+
+For maintainers: OIDC publishing requires one-time setup in npm. See the detailed guide:
+
+📖 **[Complete OIDC Setup Guide (in Japanese)](./docs/NPM_SETUP.md)**
+
+> **Note:** npm Trusted Publisher setup must be done via [npmjs.com](https://www.npmjs.com/) Web UI.
+> CLI/terminal configuration is not currently supported by npm.
+
+### Migration from Local Release Scripts
+
+The following npm scripts have been **removed** (now automated via GitHub Actions):
+
+```bash
+# 🚫 No longer available
+npm run release:patch
+npm run release:minor
+npm run release:major
+npm run release:beta
+```
+
+All releases are now handled automatically through GitHub Actions workflows.
+
+---
+
 ## Troubleshooting
 
 ### Authentication failed
@@ -381,6 +441,8 @@ MIT
 ## Related
 
 - [日本語 README](./README.ja.md)
+- [npm Publish Release Flow (in Japanese)](./docs/RELEASE_FLOW.md)
+- [npm OIDC Setup Guide (in Japanese)](./docs/NPM_SETUP.md)
 
 ---
 

package/dist/chunk-MM4GCVPE.mjs

@@ -0,0 +1,549 @@
+import {
+  __publicField
+} from "./chunk-QZ7TP4HQ.mjs";
+
+// src/github/client.ts
+import { execSync } from "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 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/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/github/batch-sync.ts
+var _BatchLabelSync = class _BatchLabelSync {
+  /**
+   * 複数リポジトリへのラベル一括同期
+   */
+  async syncMultiple(labels, options) {
+    const repos = await this.getTargetRepositories(options);
+    const results = [];
+    console.log(colorize(`
+\u{1F4CB} Target repositories: ${repos.length}`, "cyan"));
+    let completed = 0;
+    const parallel = options.parallel || _BatchLabelSync.DEFAULT_PARALLEL;
+    for (let i = 0; i < repos.length; i += parallel) {
+      const batch = repos.slice(i, i + parallel);
+      const batchResults = await Promise.allSettled(
+        batch.map((repo) => this.syncSingleRepo(repo, labels, options))
+      );
+      batchResults.forEach((result, index) => {
+        const repo = batch[index];
+        if (result.status === "fulfilled") {
+          results.push(result.value);
+          completed++;
+          console.log(colorize(`\u2705 [${completed}/${repos.length}] ${repo}`, "green"));
+        } else {
+          results.push({
+            repository: repo,
+            status: "failed",
+            error: result.reason?.message || "Unknown error"
+          });
+          completed++;
+          console.log(colorize(`\u274C [${completed}/${repos.length}] ${repo}: ${result.reason}`, "red"));
+        }
+      });
+    }
+    return results;
+  }
+  /**
+   * 単一リポジトリへの同期
+   */
+  async syncSingleRepo(repository, labels, options) {
+    try {
+      const [owner, repo] = repository.split("/");
+      if (!owner || !repo) {
+        throw new Error(`Invalid repository format: ${repository}. Expected format: owner/repo`);
+      }
+      const sync = new GitHubLabelSync({
+        owner,
+        repo,
+        deleteExtra: options.mode === "replace",
+        dryRun: options.dryRun || false
+      });
+      const result = await sync.syncLabels(labels);
+      return {
+        repository,
+        status: "success",
+        result
+      };
+    } catch (error2) {
+      return {
+        repository,
+        status: "failed",
+        error: error2 instanceof Error ? error2.message : "Unknown error"
+      };
+    }
+  }
+  /**
+   * 対象リポジトリリストの取得
+   */
+  async getTargetRepositories(options) {
+    if (options.repositories && options.repositories.length > 0) {
+      return options.repositories;
+    }
+    if (options.organization) {
+      return this.getOrganizationRepos(options.organization, options.filter);
+    }
+    if (options.user) {
+      return this.getUserRepos(options.user, options.filter);
+    }
+    throw new Error("No target repositories specified");
+  }
+  /**
+   * 組織のリポジトリ一覧を取得
+   */
+  async getOrganizationRepos(org, filter) {
+    const { execSync: execSync2 } = await import("child_process");
+    try {
+      const command = `gh repo list ${org} --json nameWithOwner,visibility,language,isArchived --limit 1000`;
+      const output = execSync2(command, { encoding: "utf-8" });
+      const repos = JSON.parse(output);
+      return repos.filter((repo) => {
+        if (filter?.visibility && filter.visibility !== "all" && repo.visibility !== filter.visibility) {
+          return false;
+        }
+        if (filter?.language && repo.language !== filter.language) {
+          return false;
+        }
+        if (filter?.archived !== void 0 && repo.isArchived !== filter.archived) {
+          return false;
+        }
+        return true;
+      }).map((repo) => repo.nameWithOwner);
+    } catch (error2) {
+      throw new Error(`Failed to fetch organization repos: ${error2}`);
+    }
+  }
+  /**
+   * ユーザーのリポジトリ一覧を取得
+   */
+  async getUserRepos(user, filter) {
+    const { execSync: execSync2 } = await import("child_process");
+    try {
+      const command = `gh repo list ${user} --json nameWithOwner,visibility,language,isArchived --limit 1000`;
+      const output = execSync2(command, { encoding: "utf-8" });
+      const repos = JSON.parse(output);
+      return repos.filter((repo) => {
+        if (filter?.visibility && filter.visibility !== "all" && repo.visibility !== filter.visibility) {
+          return false;
+        }
+        if (filter?.language && repo.language !== filter.language) {
+          return false;
+        }
+        if (filter?.archived !== void 0 && repo.isArchived !== filter.archived) {
+          return false;
+        }
+        return true;
+      }).map((repo) => repo.nameWithOwner);
+    } catch (error2) {
+      throw new Error(`Failed to fetch user repos: ${error2}`);
+    }
+  }
+  /**
+   * 結果サマリーの生成
+   */
+  generateSummary(results) {
+    const successful = results.filter((r) => r.status === "success").length;
+    const failed = results.filter((r) => r.status === "failed").length;
+    const skipped = results.filter((r) => r.status === "skipped").length;
+    let summary = "\n\u{1F4CA} Batch Sync Summary:\n";
+    summary += `\u2705 Successful: ${successful}
+`;
+    if (failed > 0) summary += `\u274C Failed: ${failed}
+`;
+    if (skipped > 0) summary += `\u23ED\uFE0F  Skipped: ${skipped}
+`;
+    const failedRepos = results.filter((r) => r.status === "failed");
+    if (failedRepos.length > 0) {
+      summary += "\n\u274C Failed repositories:\n";
+      failedRepos.forEach((repo) => {
+        summary += `  - ${repo.repository}: ${repo.error}
+`;
+      });
+    }
+    return summary;
+  }
+};
+__publicField(_BatchLabelSync, "DEFAULT_PARALLEL", 3);
+var BatchLabelSync = _BatchLabelSync;
+
+export {
+  GitHubClient,
+  GitHubLabelSync,
+  colorize,
+  success,
+  error,
+  warning,
+  info,
+  header,
+  Spinner,
+  BatchLabelSync
+};