@asagiri-design/labels-config 0.2.2

package/dist/cli.mjs

@@ -0,0 +1,436 @@
+#!/usr/bin/env node
+import {
+  LabelManager
+} from "./chunk-DSI7SDAM.mjs";
+import {
+  CONFIG_TEMPLATES,
+  ConfigLoader,
+  listTemplates
+} from "./chunk-QJLMZSVA.mjs";
+import {
+  validateWithDetails
+} from "./chunk-VU2JB66N.mjs";
+import {
+  GitHubLabelSync
+} from "./chunk-4ZUJQMV7.mjs";
+import {
+  __publicField
+} from "./chunk-QZ7TP4HQ.mjs";
+
+// src/cli.ts
+import { promises as fs } from "fs";
+
+// 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 fs.access(file);
+    } catch {
+      console.error(error(`File not found: ${file}`));
+      process.exit(1);
+    }
+    spinner.start(`Reading ${file}`);
+    const content = await fs.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 fs.access(file);
+    } catch {
+      console.error(error(`File not found: ${file}`));
+      process.exit(1);
+    }
+    spinner.start(`Loading labels from ${file}`);
+    const content = await fs.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 fs.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 fs.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);
+});

package/dist/config/index.d.mts

@@ -0,0 +1,49 @@
+import { L as LabelConfig, a as LabelRegistry } from '../types-CkwsO1Iu.mjs';
+
+/**
+ * Configuration Loader
+ * Load label configurations from files and various sources
+ */
+
+interface LoaderOptions {
+    /** Strict validation mode */
+    strict?: boolean;
+}
+declare class ConfigLoader {
+    private strict;
+    constructor(options?: LoaderOptions);
+    /**
+     * Load labels from JSON object
+     */
+    loadFromJSON(data: unknown): LabelConfig[];
+    /**
+     * Load from JSON string
+     */
+    loadFromString(jsonString: string): LabelConfig[];
+    /**
+     * Load from registry object
+     */
+    loadRegistry(registry: LabelRegistry): LabelConfig[];
+}
+
+/**
+ * Configuration Templates
+ * Pre-built label configurations for common use cases
+ */
+
+/**
+ * All available templates
+ */
+declare const CONFIG_TEMPLATES: {
+    minimal: LabelConfig[];
+    github: LabelConfig[];
+    react: LabelConfig[];
+    vue: LabelConfig[];
+    frontend: LabelConfig[];
+    'prod-en': LabelConfig[];
+    'prod-ja': LabelConfig[];
+    prod: LabelConfig[];
+    agile: LabelConfig[];
+};
+
+export { CONFIG_TEMPLATES, ConfigLoader, type LoaderOptions };

package/dist/config/index.d.ts

@@ -0,0 +1,49 @@
+import { L as LabelConfig, a as LabelRegistry } from '../types-CkwsO1Iu.js';
+
+/**
+ * Configuration Loader
+ * Load label configurations from files and various sources
+ */
+
+interface LoaderOptions {
+    /** Strict validation mode */
+    strict?: boolean;
+}
+declare class ConfigLoader {
+    private strict;
+    constructor(options?: LoaderOptions);
+    /**
+     * Load labels from JSON object
+     */
+    loadFromJSON(data: unknown): LabelConfig[];
+    /**
+     * Load from JSON string
+     */
+    loadFromString(jsonString: string): LabelConfig[];
+    /**
+     * Load from registry object
+     */
+    loadRegistry(registry: LabelRegistry): LabelConfig[];
+}
+
+/**
+ * Configuration Templates
+ * Pre-built label configurations for common use cases
+ */
+
+/**
+ * All available templates
+ */
+declare const CONFIG_TEMPLATES: {
+    minimal: LabelConfig[];
+    github: LabelConfig[];
+    react: LabelConfig[];
+    vue: LabelConfig[];
+    frontend: LabelConfig[];
+    'prod-en': LabelConfig[];
+    'prod-ja': LabelConfig[];
+    prod: LabelConfig[];
+    agile: LabelConfig[];
+};
+
+export { CONFIG_TEMPLATES, ConfigLoader, type LoaderOptions };