featuredrop 1.1.0 → 1.3.0

package/dist/featuredrop.cjs

@@ -0,0 +1,1377 @@
+#!/usr/bin/env node
+'use strict';
+
+var promises$1 = require('readline/promises');
+var promises = require('fs/promises');
+var path = require('path');
+var zod = require('zod');
+var module$1 = require('module');
+
+var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
+// src/dependencies.ts
+function getDirectDependencies(feature) {
+  const dependsOn = feature.dependsOn;
+  if (!dependsOn) return [];
+  const seen = dependsOn.seen ?? [];
+  const clicked = dependsOn.clicked ?? [];
+  const dismissed = dependsOn.dismissed ?? [];
+  const unique = /* @__PURE__ */ new Set();
+  for (const id of [...seen, ...clicked, ...dismissed]) {
+    if (id) unique.add(id);
+  }
+  return Array.from(unique);
+}
+function hasDependencyCycle(manifest) {
+  const ids = new Set(manifest.map((feature) => feature.id));
+  const outgoing = /* @__PURE__ */ new Map();
+  const indegree = /* @__PURE__ */ new Map();
+  for (const feature of manifest) {
+    outgoing.set(feature.id, /* @__PURE__ */ new Set());
+    indegree.set(feature.id, 0);
+  }
+  for (const feature of manifest) {
+    for (const dependencyId of getDirectDependencies(feature)) {
+      if (!ids.has(dependencyId)) continue;
+      const edges = outgoing.get(dependencyId);
+      if (!edges || edges.has(feature.id)) continue;
+      edges.add(feature.id);
+      indegree.set(feature.id, (indegree.get(feature.id) ?? 0) + 1);
+    }
+  }
+  const queue = [];
+  for (const feature of manifest) {
+    if ((indegree.get(feature.id) ?? 0) === 0) queue.push(feature.id);
+  }
+  let visited = 0;
+  while (queue.length > 0) {
+    const id = queue.shift();
+    if (!id) continue;
+    visited += 1;
+    const edges = outgoing.get(id);
+    if (!edges) continue;
+    for (const nextId of edges) {
+      const nextDegree = (indegree.get(nextId) ?? 0) - 1;
+      indegree.set(nextId, nextDegree);
+      if (nextDegree === 0) queue.push(nextId);
+    }
+  }
+  return visited !== manifest.length;
+}
+function isRecord(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function isValidDate(value) {
+  return Number.isFinite(new Date(value).getTime());
+}
+var nonEmptyString = zod.z.string().trim().min(1, "must be a non-empty string");
+var isoDateString = nonEmptyString.refine(isValidDate, {
+  message: "must be a valid date",
+  params: { featuredropCode: "invalid_date" }
+});
+var dependsOnSchema = zod.z.object({
+  seen: zod.z.array(zod.z.string()).optional(),
+  clicked: zod.z.array(zod.z.string()).optional(),
+  dismissed: zod.z.array(zod.z.string()).optional()
+}).optional();
+var ctaSchema = zod.z.object({
+  label: nonEmptyString,
+  url: nonEmptyString
+}).optional();
+var featureEntrySchema = zod.z.object({
+  id: nonEmptyString,
+  label: nonEmptyString,
+  releasedAt: isoDateString,
+  showNewUntil: isoDateString,
+  description: zod.z.string().optional(),
+  flagKey: zod.z.string().optional(),
+  product: zod.z.string().optional(),
+  url: zod.z.string().optional(),
+  image: zod.z.string().optional(),
+  type: zod.z.enum(["feature", "improvement", "fix", "breaking"]).optional(),
+  priority: zod.z.enum(["critical", "normal", "low"]).optional(),
+  cta: ctaSchema,
+  meta: zod.z.record(zod.z.unknown()).optional(),
+  dependsOn: dependsOnSchema
+}).passthrough();
+zod.z.array(featureEntrySchema);
+function toIssuePath(path) {
+  if (path.length === 0) return "$";
+  let output = "";
+  for (const part of path) {
+    if (typeof part === "number") output += `[${part}]`;
+    else output += output ? `.${part}` : part;
+  }
+  return output;
+}
+function mapZodIssue(issue) {
+  const codeParam = issue.params?.featuredropCode;
+  if (codeParam === "invalid_date") {
+    return {
+      path: toIssuePath(issue.path),
+      message: issue.message,
+      code: "invalid_date"
+    };
+  }
+  if (issue.code === "invalid_type") {
+    return {
+      path: toIssuePath(issue.path),
+      message: issue.message,
+      code: issue.received === "undefined" ? "missing_required" : "invalid_type"
+    };
+  }
+  return {
+    path: toIssuePath(issue.path),
+    message: issue.message,
+    code: "invalid_value"
+  };
+}
+var UNSAFE_META_KEYS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
+function isSafeUrl(value) {
+  const normalized = value.trim();
+  if (!normalized) return false;
+  if (/^(\/|\.\/|\.\.\/|\?|#)/.test(normalized)) return true;
+  if (/^https?:\/\//i.test(normalized)) return true;
+  return false;
+}
+function findUnsafeMetaPath(value, path = "meta") {
+  if (Array.isArray(value)) {
+    for (let index = 0; index < value.length; index++) {
+      const nested = findUnsafeMetaPath(value[index], `${path}[${index}]`);
+      if (nested) return nested;
+    }
+    return null;
+  }
+  if (!isRecord(value)) return null;
+  for (const [key, nestedValue] of Object.entries(value)) {
+    if (UNSAFE_META_KEYS.has(key)) {
+      return `${path}.${key}`;
+    }
+    const nested = findUnsafeMetaPath(nestedValue, `${path}.${key}`);
+    if (nested) return nested;
+  }
+  return null;
+}
+function validateFeatureEntry(raw, index) {
+  if (!isRecord(raw)) {
+    return {
+      issues: [
+        {
+          path: `[${index}]`,
+          message: "Feature entry must be an object",
+          code: "invalid_type"
+        }
+      ]
+    };
+  }
+  const parsed = featureEntrySchema.safeParse(raw);
+  if (!parsed.success) {
+    return {
+      issues: parsed.error.issues.map((issue) => ({
+        ...mapZodIssue(issue),
+        path: `[${index}]${issue.path.length > 0 ? `.${toIssuePath(issue.path)}` : ""}`
+      }))
+    };
+  }
+  return {
+    issues: [],
+    entry: parsed.data
+  };
+}
+function validateManifest(data) {
+  const errors = [];
+  if (!Array.isArray(data)) {
+    return {
+      valid: false,
+      errors: [
+        {
+          path: "$",
+          message: "Manifest must be an array",
+          code: "invalid_type"
+        }
+      ]
+    };
+  }
+  const entries = [];
+  const seenIds = /* @__PURE__ */ new Set();
+  data.forEach((item, index) => {
+    const result = validateFeatureEntry(item, index);
+    errors.push(...result.issues);
+    if (!result.entry) return;
+    if (seenIds.has(result.entry.id)) {
+      errors.push({
+        path: `[${index}].id`,
+        message: `Duplicate feature id "${result.entry.id}"`,
+        code: "duplicate_id"
+      });
+      return;
+    }
+    seenIds.add(result.entry.id);
+    entries.push(result.entry);
+  });
+  if (entries.length > 0 && hasDependencyCycle(entries)) {
+    errors.push({
+      path: "$",
+      message: "Circular dependsOn relationship detected",
+      code: "circular_dependency"
+    });
+  }
+  for (let index = 0; index < entries.length; index++) {
+    const entry = entries[index];
+    if (new Date(entry.showNewUntil).getTime() <= new Date(entry.releasedAt).getTime()) {
+      errors.push({
+        path: `[${index}].showNewUntil`,
+        message: "showNewUntil must be after releasedAt",
+        code: "invalid_value"
+      });
+    }
+    if (entry.url && !isSafeUrl(entry.url)) {
+      errors.push({
+        path: `[${index}].url`,
+        message: "url must be http, https, or relative",
+        code: "invalid_value"
+      });
+    }
+    if (entry.image && !isSafeUrl(entry.image)) {
+      errors.push({
+        path: `[${index}].image`,
+        message: "image must be http, https, or relative",
+        code: "invalid_value"
+      });
+    }
+    if (entry.cta?.url && !isSafeUrl(entry.cta.url)) {
+      errors.push({
+        path: `[${index}].cta.url`,
+        message: "cta.url must be http, https, or relative",
+        code: "invalid_value"
+      });
+    }
+    const unsafeMetaPath = findUnsafeMetaPath(entry.meta);
+    if (unsafeMetaPath) {
+      errors.push({
+        path: `[${index}].${unsafeMetaPath}`,
+        message: `meta contains unsafe key "${unsafeMetaPath.split(".").pop()}"`,
+        code: "invalid_value"
+      });
+    }
+  }
+  return {
+    valid: errors.length === 0,
+    errors
+  };
+}
+
+// src/changelog-as-code.ts
+function parseScalar(raw) {
+  const value = raw.trim();
+  if (!value) return "";
+  if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+    return value.slice(1, -1);
+  }
+  if (value === "true") return true;
+  if (value === "false") return false;
+  if (value === "null") return null;
+  if (/^-?\d+(\.\d+)?$/.test(value)) return Number(value);
+  if (value.startsWith("[") && value.endsWith("]")) {
+    const inner = value.slice(1, -1).trim();
+    if (!inner) return [];
+    return inner.split(",").map((part) => String(parseScalar(part.trim())));
+  }
+  return value;
+}
+function parseFrontmatter(raw) {
+  const lines = raw.split(/\r?\n/);
+  const root = {};
+  const stack = [
+    { indent: -1, value: root }
+  ];
+  const isArrayContext = (idx) => {
+    for (let i = idx + 1; i < lines.length; i++) {
+      const line = lines[i];
+      if (!line.trim()) continue;
+      const indent = line.length - line.trimStart().length;
+      if (indent <= lines[idx].length - lines[idx].trimStart().length) return false;
+      return line.trimStart().startsWith("- ");
+    }
+    return false;
+  };
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (!line.trim() || line.trimStart().startsWith("#")) continue;
+    const indent = line.length - line.trimStart().length;
+    const trimmed = line.trim();
+    while (stack.length > 1 && indent <= stack[stack.length - 1].indent) {
+      stack.pop();
+    }
+    const current = stack[stack.length - 1].value;
+    if (trimmed.startsWith("- ")) {
+      if (!Array.isArray(current)) {
+        throw new Error(`Invalid frontmatter list at line ${i + 1}`);
+      }
+      const item = trimmed.slice(2).trim();
+      current.push(parseScalar(item));
+      continue;
+    }
+    const colon = trimmed.indexOf(":");
+    if (colon === -1) {
+      throw new Error(`Invalid frontmatter line ${i + 1}: ${trimmed}`);
+    }
+    const key = trimmed.slice(0, colon).trim();
+    const rest = trimmed.slice(colon + 1).trim();
+    if (Array.isArray(current)) {
+      throw new Error(`Unexpected key in list at line ${i + 1}`);
+    }
+    if (!rest) {
+      const container = isArrayContext(i) ? [] : {};
+      current[key] = container;
+      stack.push({ indent, value: container });
+      continue;
+    }
+    current[key] = parseScalar(rest);
+  }
+  return root;
+}
+function splitFrontmatter(markdown) {
+  const normalized = markdown.replace(/\r\n/g, "\n");
+  if (!normalized.startsWith("---\n")) {
+    return { frontmatter: {}, body: normalized.trim() };
+  }
+  const end = normalized.indexOf("\n---\n", 4);
+  if (end === -1) {
+    throw new Error("Frontmatter block is not closed with ---");
+  }
+  const fmRaw = normalized.slice(4, end);
+  const body = normalized.slice(end + 5).trim();
+  return {
+    frontmatter: parseFrontmatter(fmRaw),
+    body
+  };
+}
+function asString(value, field, source) {
+  if (typeof value !== "string" || !value.trim()) {
+    throw new Error(`${source}: "${field}" must be a non-empty string`);
+  }
+  return value;
+}
+function asOptionalObject(value, field, source) {
+  if (value === void 0) return void 0;
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error(`${source}: "${field}" must be an object`);
+  }
+  return value;
+}
+function parseFeatureFile(markdown, source = "feature.md") {
+  const { frontmatter, body } = splitFrontmatter(markdown);
+  const entry = {
+    id: asString(frontmatter.id, "id", source),
+    label: asString(frontmatter.label, "label", source),
+    releasedAt: asString(frontmatter.releasedAt, "releasedAt", source),
+    showNewUntil: asString(frontmatter.showNewUntil, "showNewUntil", source),
+    description: body || void 0
+  };
+  if (frontmatter.sidebarKey !== void 0) entry.sidebarKey = asString(frontmatter.sidebarKey, "sidebarKey", source);
+  if (frontmatter.category !== void 0) entry.category = asString(frontmatter.category, "category", source);
+  if (frontmatter.product !== void 0) entry.product = asString(frontmatter.product, "product", source);
+  if (frontmatter.url !== void 0) entry.url = asString(frontmatter.url, "url", source);
+  if (frontmatter.flagKey !== void 0) entry.flagKey = asString(frontmatter.flagKey, "flagKey", source);
+  if (frontmatter.image !== void 0) entry.image = asString(frontmatter.image, "image", source);
+  if (frontmatter.publishAt !== void 0) entry.publishAt = asString(frontmatter.publishAt, "publishAt", source);
+  if (frontmatter.version !== void 0) {
+    if (typeof frontmatter.version === "string" || typeof frontmatter.version === "object") {
+      entry.version = frontmatter.version;
+    } else {
+      throw new Error(`${source}: "version" must be a string or object`);
+    }
+  }
+  if (frontmatter.type !== void 0) {
+    const type = asString(frontmatter.type, "type", source);
+    if (!["feature", "improvement", "fix", "breaking"].includes(type)) {
+      throw new Error(`${source}: invalid "type" value "${type}"`);
+    }
+    entry.type = type;
+  }
+  if (frontmatter.priority !== void 0) {
+    const priority = asString(frontmatter.priority, "priority", source);
+    if (!["critical", "normal", "low"].includes(priority)) {
+      throw new Error(`${source}: invalid "priority" value "${priority}"`);
+    }
+    entry.priority = priority;
+  }
+  const cta = asOptionalObject(frontmatter.cta, "cta", source);
+  if (cta) {
+    entry.cta = {
+      label: asString(cta.label, "cta.label", source),
+      url: asString(cta.url, "cta.url", source)
+    };
+  }
+  const audience = asOptionalObject(frontmatter.audience, "audience", source);
+  if (audience) {
+    const parsedAudience = {};
+    for (const field of ["plan", "role", "region"]) {
+      const value = audience[field];
+      if (value !== void 0) {
+        if (!Array.isArray(value) || value.some((item) => typeof item !== "string")) {
+          throw new Error(`${source}: "audience.${field}" must be string[]`);
+        }
+        parsedAudience[field] = value;
+      }
+    }
+    if (audience.custom !== void 0) {
+      if (!audience.custom || typeof audience.custom !== "object" || Array.isArray(audience.custom)) {
+        throw new Error(`${source}: "audience.custom" must be an object`);
+      }
+      parsedAudience.custom = audience.custom;
+    }
+    entry.audience = parsedAudience;
+  }
+  return entry;
+}
+function normalizePattern(pattern) {
+  const normalized = pattern.replaceAll("\\", "/");
+  if (normalized.endsWith("/**/*.md")) {
+    return {
+      baseDir: normalized.slice(0, -"/**/*.md".length),
+      ext: ".md"
+    };
+  }
+  throw new Error(`Unsupported pattern "${pattern}". Use "features/**/*.md" style patterns.`);
+}
+async function collectFiles(dir, ext) {
+  const out = [];
+  async function walk(current) {
+    let entries;
+    try {
+      entries = await promises.readdir(current, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      const fullPath = path.join(current, entry.name);
+      if (entry.isDirectory()) {
+        await walk(fullPath);
+        continue;
+      }
+      if (entry.isFile() && entry.name.endsWith(ext)) {
+        out.push(fullPath);
+      }
+    }
+  }
+  await walk(dir);
+  return out.sort();
+}
+async function buildManifestFromPattern(options = {}) {
+  const cwd = options.cwd ?? process.cwd();
+  const pattern = options.pattern ?? "features/**/*.md";
+  const { baseDir, ext } = normalizePattern(pattern);
+  const baseAbs = path.join(cwd, baseDir);
+  const stats = await promises.stat(baseAbs).catch(() => null);
+  if (!stats || !stats.isDirectory()) {
+    throw new Error(`Pattern base directory does not exist: ${baseDir}`);
+  }
+  const files = await collectFiles(baseAbs, ext);
+  const entries = [];
+  const seenIds = /* @__PURE__ */ new Set();
+  for (const file of files) {
+    const content = await promises.readFile(file, "utf8");
+    const source = path.relative(cwd, file).split(path.sep).join("/");
+    const entry = parseFeatureFile(content, source);
+    if (seenIds.has(entry.id)) {
+      throw new Error(`Duplicate feature id "${entry.id}" found at ${source}`);
+    }
+    seenIds.add(entry.id);
+    entries.push(entry);
+  }
+  if (options.outFile) {
+    const outPath = path.join(cwd, options.outFile);
+    await promises.writeFile(outPath, `${JSON.stringify(entries, null, 2)}
+`, "utf8");
+  }
+  return entries;
+}
+async function validateFeatureFiles(options = {}) {
+  const entries = await buildManifestFromPattern(options);
+  const result = validateManifest(entries);
+  if (!result.valid) {
+    const message = result.errors.map((issue) => `${issue.path}: ${issue.message}`).join("; ");
+    throw new Error(`Manifest validation failed: ${message}`);
+  }
+}
+
+// src/cli-utils.ts
+function computeManifestStats(entries) {
+  const byType = {};
+  const byCategory = {};
+  for (const entry of entries) {
+    const type = entry.type ?? "feature";
+    byType[type] = (byType[type] ?? 0) + 1;
+    if (entry.category) {
+      byCategory[entry.category] = (byCategory[entry.category] ?? 0) + 1;
+    }
+  }
+  const sortedByDate = [...entries].sort(
+    (a, b) => new Date(b.releasedAt).getTime() - new Date(a.releasedAt).getTime()
+  );
+  return {
+    total: entries.length,
+    byType,
+    byCategory,
+    newestRelease: sortedByDate[0]?.releasedAt ?? null,
+    oldestRelease: sortedByDate[sortedByDate.length - 1]?.releasedAt ?? null
+  };
+}
+function generateMarkdownChangelog(entries) {
+  const sorted = [...entries].sort(
+    (a, b) => new Date(b.releasedAt).getTime() - new Date(a.releasedAt).getTime()
+  );
+  const sections = sorted.map((entry) => {
+    const lines = [
+      `## ${entry.label}`,
+      "",
+      `- **ID**: \`${entry.id}\``,
+      `- **Released**: ${entry.releasedAt}`
+    ];
+    if (entry.type) lines.push(`- **Type**: ${entry.type}`);
+    if (entry.category) lines.push(`- **Category**: ${entry.category}`);
+    if (entry.showNewUntil) lines.push(`- **Show new until**: ${entry.showNewUntil}`);
+    if (entry.cta) lines.push(`- **CTA**: [${entry.cta.label}](${entry.cta.url})`);
+    if (entry.description) {
+      lines.push("", entry.description.trim());
+    }
+    return lines.join("\n");
+  });
+  return `# Generated Changelog
+
+${sections.join("\n\n---\n\n")}
+`;
+}
+function isIsoWithTimezone(value) {
+  if (!value.includes("T")) return false;
+  if (!(value.endsWith("Z") || /[+-]\d{2}:\d{2}$/.test(value))) return false;
+  return Number.isFinite(new Date(value).getTime());
+}
+function runDoctor(entries, now = /* @__PURE__ */ new Date()) {
+  const checks = [];
+  const warnings = [];
+  const errors = [];
+  checks.push(`Manifest entries loaded: ${entries.length}`);
+  const ids = /* @__PURE__ */ new Set();
+  let duplicateCount = 0;
+  for (const entry of entries) {
+    if (ids.has(entry.id)) duplicateCount += 1;
+    ids.add(entry.id);
+  }
+  if (duplicateCount > 0) {
+    errors.push(`${duplicateCount} duplicate feature id(s) found`);
+  } else {
+    checks.push("No duplicate IDs");
+  }
+  let invalidDateCount = 0;
+  let reversedDateCount = 0;
+  let expiredCount = 0;
+  let scheduledCount = 0;
+  let missingDescriptionCount = 0;
+  for (const entry of entries) {
+    if (!entry.description?.trim()) missingDescriptionCount += 1;
+    if (!isIsoWithTimezone(entry.releasedAt) || !isIsoWithTimezone(entry.showNewUntil)) {
+      invalidDateCount += 1;
+      continue;
+    }
+    const released = new Date(entry.releasedAt).getTime();
+    const showUntil = new Date(entry.showNewUntil).getTime();
+    if (showUntil <= released) reversedDateCount += 1;
+    if (showUntil < now.getTime()) expiredCount += 1;
+    if (entry.publishAt) {
+      const publishMs = new Date(entry.publishAt).getTime();
+      if (Number.isFinite(publishMs) && publishMs > now.getTime()) scheduledCount += 1;
+    }
+  }
+  if (invalidDateCount > 0) {
+    errors.push(`${invalidDateCount} entries have invalid ISO 8601 dates with timezone`);
+  } else {
+    checks.push("All dates are valid ISO 8601 with timezone");
+  }
+  if (reversedDateCount > 0) {
+    errors.push(`${reversedDateCount} entries have showNewUntil before/at releasedAt`);
+  }
+  if (expiredCount > 0) warnings.push(`${expiredCount} entries have showNewUntil in the past`);
+  if (scheduledCount > 0) warnings.push(`${scheduledCount} entries have publishAt in the future`);
+  if (missingDescriptionCount > 0) {
+    errors.push(`${missingDescriptionCount} entries have no description`);
+  } else {
+    checks.push("All entries have descriptions");
+  }
+  if (hasDependencyCycle(entries)) {
+    errors.push("Circular dependsOn relationship detected");
+  } else {
+    checks.push("No circular dependencies in dependsOn chains");
+  }
+  return { checks, warnings, errors };
+}
+function isRecord2(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+async function pathExists(path) {
+  const result = await promises.stat(path).catch(() => null);
+  return !!result;
+}
+function ensureIsoDate(value, field) {
+  const parsed = new Date(value).getTime();
+  if (!Number.isFinite(parsed)) {
+    throw new Error(`"${field}" must be a valid ISO date string`);
+  }
+  return new Date(parsed).toISOString();
+}
+function withDays(date, days) {
+  return new Date(date.getTime() + days * 24 * 60 * 60 * 1e3).toISOString();
+}
+function toSlug(value) {
+  return value.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").replace(/-{2,}/g, "-");
+}
+function getPathDate(dateIso) {
+  return dateIso.slice(0, 10);
+}
+function getFrontmatterValue(value) {
+  return value.replace(/\n/g, " ").trim();
+}
+function slugifyFeatureId(label) {
+  const slug = toSlug(label);
+  return slug || "feature";
+}
+function createFeatureEntry(options, now = /* @__PURE__ */ new Date()) {
+  const releasedAt = options.releasedAt ? ensureIsoDate(options.releasedAt, "releasedAt") : now.toISOString();
+  const showNewUntil = options.showNewUntil ? ensureIsoDate(options.showNewUntil, "showNewUntil") : withDays(new Date(releasedAt), options.showDays ?? 14);
+  const id = options.id ? slugifyFeatureId(options.id) : slugifyFeatureId(options.label);
+  const entry = {
+    id,
+    label: options.label.trim(),
+    releasedAt,
+    showNewUntil,
+    type: options.type ?? "feature"
+  };
+  if (options.description?.trim()) entry.description = options.description.trim();
+  if (options.category?.trim()) entry.category = options.category.trim();
+  if (options.url?.trim()) entry.url = options.url.trim();
+  return entry;
+}
+function renderFeatureMarkdown(entry) {
+  const lines = [
+    "---",
+    `id: ${getFrontmatterValue(entry.id)}`,
+    `label: ${getFrontmatterValue(entry.label)}`,
+    `releasedAt: ${entry.releasedAt}`,
+    `showNewUntil: ${entry.showNewUntil}`
+  ];
+  if (entry.type) lines.push(`type: ${entry.type}`);
+  if (entry.category) lines.push(`category: ${getFrontmatterValue(entry.category)}`);
+  if (entry.url) lines.push(`url: ${getFrontmatterValue(entry.url)}`);
+  lines.push("---", "");
+  if (entry.description) {
+    lines.push(entry.description.trim(), "");
+  } else {
+    lines.push("Describe the feature here.", "");
+  }
+  return `${lines.join("\n")}`;
+}
+function getNextAvailablePath(existingNames, baseName) {
+  if (!existingNames.has(baseName)) return baseName;
+  const ext = baseName.endsWith(".md") ? ".md" : "";
+  const withoutExt = ext ? baseName.slice(0, -ext.length) : baseName;
+  let index = 2;
+  while (existingNames.has(`${withoutExt}-${index}${ext}`)) {
+    index += 1;
+  }
+  return `${withoutExt}-${index}${ext}`;
+}
+async function detectProjectFormat(cwd, explicit) {
+  if (explicit) return explicit;
+  if (await pathExists(path.join(cwd, "features"))) return "markdown";
+  if (await pathExists(path.join(cwd, "features.json"))) return "json";
+  return "markdown";
+}
+async function initFeaturedropProject(options = {}) {
+  const cwd = options.cwd ?? process.cwd();
+  const format = options.format ?? "markdown";
+  const now = options.now ?? /* @__PURE__ */ new Date();
+  const force = options.force ?? false;
+  const created = [];
+  if (format === "markdown") {
+    const featuresDir = path.join(cwd, "features");
+    if (await pathExists(featuresDir)) {
+      const existing = await promises.readdir(featuresDir).catch(() => []);
+      if (existing.length > 0 && !force) {
+        throw new Error("features/ already exists and is not empty (use --force to overwrite sample files)");
+      }
+    }
+    await promises.mkdir(featuresDir, { recursive: true });
+    const sample2 = createFeatureEntry(
+      {
+        id: "welcome-featuredrop",
+        label: "Welcome to featuredrop",
+        description: "Update this file with your first product announcement.",
+        category: "onboarding",
+        type: "feature",
+        releasedAt: now.toISOString(),
+        showDays: 30
+      },
+      now
+    );
+    const sampleName = `${getPathDate(sample2.releasedAt)}-${sample2.id}.md`;
+    const samplePath = path.join(featuresDir, sampleName);
+    await promises.writeFile(samplePath, renderFeatureMarkdown(sample2), "utf8");
+    created.push("features/");
+    created.push(`features/${sampleName}`);
+    return { format, created };
+  }
+  const manifestPath = path.join(cwd, "features.json");
+  if (await pathExists(manifestPath)) {
+    if (!force) {
+      throw new Error("features.json already exists (use --force to overwrite)");
+    }
+  }
+  const sample = createFeatureEntry(
+    {
+      id: "welcome-featuredrop",
+      label: "Welcome to featuredrop",
+      description: "Replace this sample entry with your own release notes.",
+      category: "onboarding",
+      type: "feature",
+      releasedAt: now.toISOString(),
+      showDays: 30
+    },
+    now
+  );
+  await promises.writeFile(manifestPath, `${JSON.stringify([sample], null, 2)}
+`, "utf8");
+  created.push("features.json");
+  return { format, created };
+}
+async function ensureUniqueIdForMarkdown(cwd, id) {
+  const featuresDir = path.join(cwd, "features");
+  if (!await pathExists(featuresDir)) return;
+  const entries = await buildManifestFromPattern({ cwd, pattern: "features/**/*.md" }).catch(() => []);
+  if (entries.some((entry) => entry.id === id)) {
+    throw new Error(`Feature id "${id}" already exists`);
+  }
+}
+async function addFeatureToMarkdown(cwd, entry) {
+  await promises.mkdir(path.join(cwd, "features"), { recursive: true });
+  await ensureUniqueIdForMarkdown(cwd, entry.id);
+  const existingFiles = new Set(
+    (await promises.readdir(path.join(cwd, "features")).catch(() => [])).filter((name) => name.endsWith(".md"))
+  );
+  const baseName = `${getPathDate(entry.releasedAt)}-${entry.id}.md`;
+  const fileName = getNextAvailablePath(existingFiles, baseName);
+  const relPath = `features/${fileName}`;
+  await promises.writeFile(path.join(cwd, relPath), renderFeatureMarkdown(entry), "utf8");
+  return relPath;
+}
+async function addFeatureToJson(cwd, entry) {
+  const manifestPath = path.join(cwd, "features.json");
+  const raw = await promises.readFile(manifestPath, "utf8").catch(() => "[]");
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    throw new Error("features.json is not valid JSON");
+  }
+  if (!Array.isArray(parsed)) {
+    throw new Error("features.json must contain an array of feature entries");
+  }
+  const existing = parsed;
+  if (existing.some((item) => item.id === entry.id)) {
+    throw new Error(`Feature id "${entry.id}" already exists`);
+  }
+  const next = [...existing, entry];
+  const validation = validateManifest(next);
+  if (!validation.valid) {
+    throw new Error(`features.json validation failed: ${validation.errors[0]?.message ?? "unknown error"}`);
+  }
+  await promises.writeFile(manifestPath, `${JSON.stringify(next, null, 2)}
+`, "utf8");
+  return "features.json";
+}
+async function addFeatureEntry(options) {
+  const cwd = options.cwd ?? process.cwd();
+  const format = await detectProjectFormat(cwd, options.format);
+  const entry = createFeatureEntry(options);
+  const path = format === "markdown" ? await addFeatureToMarkdown(cwd, entry) : await addFeatureToJson(cwd, entry);
+  return { format, path, entry };
+}
+function pickString(obj, keys) {
+  for (const key of keys) {
+    const value = obj[key];
+    if (typeof value === "string" && value.trim()) return value.trim();
+  }
+  return void 0;
+}
+function getMigrationItems(payload) {
+  if (Array.isArray(payload)) return payload;
+  if (!isRecord2(payload)) throw new Error("Migration payload must be an array or object");
+  for (const key of ["posts", "items", "announcements", "entries"]) {
+    const value = payload[key];
+    if (Array.isArray(value)) return value;
+  }
+  throw new Error("Could not find entries array in migration payload");
+}
+function normalizeDate(raw, fallback) {
+  if (!raw) return fallback.toISOString();
+  const parsed = new Date(raw).getTime();
+  if (!Number.isFinite(parsed)) return fallback.toISOString();
+  return new Date(parsed).toISOString();
+}
+function buildFallbackId(prefix, index) {
+  return `${prefix}-entry-${index + 1}`;
+}
+var MIGRATION_PROFILES = {
+  beamer: {
+    fallbackPrefix: "beamer",
+    labelKeys: ["title", "name", "headline"],
+    idKeys: ["id", "uid", "slug", "postId", "post_id"],
+    dateKeys: ["publishedAt", "published_at", "published", "createdAt", "created_at", "date"],
+    categoryKeys: ["category", "type", "segment"],
+    urlKeys: ["url", "link", "permalink"],
+    descriptionKeys: ["description", "content", "body", "html"],
+    showUntilKeys: ["showNewUntil", "show_new_until", "newUntil", "new_until"]
+  },
+  headway: {
+    fallbackPrefix: "headway",
+    labelKeys: ["title", "name", "headline"],
+    idKeys: ["id", "slug", "entryId", "entry_id"],
+    dateKeys: ["publishedAt", "published_at", "createdAt", "created_at", "date"],
+    categoryKeys: ["category", "tag", "tags"],
+    urlKeys: ["url", "link", "permalink"],
+    descriptionKeys: ["description", "summary", "content", "body"],
+    showUntilKeys: ["showNewUntil", "new_until"]
+  },
+  announcekit: {
+    fallbackPrefix: "announcekit",
+    labelKeys: ["title", "subject", "name"],
+    idKeys: ["id", "post_id", "postId", "slug"],
+    dateKeys: ["published_at", "publishedAt", "created_at", "createdAt", "date"],
+    categoryKeys: ["category", "segment", "tab", "label"],
+    urlKeys: ["url", "link", "permalink"],
+    descriptionKeys: ["description", "content", "html", "body"],
+    showUntilKeys: ["show_new_until", "showNewUntil", "new_until"]
+  },
+  canny: {
+    fallbackPrefix: "canny",
+    labelKeys: ["title", "name"],
+    idKeys: ["id", "postId", "post_id", "slug"],
+    dateKeys: ["createdAt", "created_at", "publishedAt", "published_at", "date"],
+    categoryKeys: ["category", "type", "boardName"],
+    urlKeys: ["url", "link", "permalink"],
+    descriptionKeys: ["details", "description", "content", "body"],
+    showUntilKeys: ["showNewUntil", "new_until"]
+  },
+  launchnotes: {
+    fallbackPrefix: "launchnotes",
+    labelKeys: ["title", "headline", "name"],
+    idKeys: ["id", "slug", "noteId", "note_id"],
+    dateKeys: ["publishedAt", "published_at", "createdAt", "created_at", "date"],
+    categoryKeys: ["category", "segment", "channel"],
+    urlKeys: ["url", "link", "permalink"],
+    descriptionKeys: ["description", "body", "content", "summary"],
+    showUntilKeys: ["showNewUntil", "new_until"]
+  }
+};
+function migrateFromSourcePayload(source, payload, now = /* @__PURE__ */ new Date()) {
+  const profile = MIGRATION_PROFILES[source];
+  const items = getMigrationItems(payload);
+  const usedIds = /* @__PURE__ */ new Set();
+  return items.map((raw, index) => {
+    if (!isRecord2(raw)) return null;
+    const release = normalizeDate(
+      pickString(raw, profile.dateKeys),
+      now
+    );
+    const label = pickString(raw, profile.labelKeys) ?? `Update ${index + 1}`;
+    const idSeed = pickString(raw, profile.idKeys) ?? label;
+    let id = slugifyFeatureId(idSeed);
+    if (!id) id = buildFallbackId(profile.fallbackPrefix, index);
+    while (usedIds.has(id)) {
+      id = `${id}-${index + 1}`;
+    }
+    usedIds.add(id);
+    const category = pickString(raw, profile.categoryKeys);
+    const url = pickString(raw, profile.urlKeys);
+    const description = pickString(raw, profile.descriptionKeys);
+    const explicitShowUntil = normalizeDate(
+      pickString(raw, profile.showUntilKeys),
+      new Date(withDays(new Date(release), 30))
+    );
+    const entry = {
+      id,
+      label,
+      releasedAt: release,
+      showNewUntil: explicitShowUntil,
+      type: "feature"
+    };
+    if (description) entry.description = description;
+    if (category) entry.category = category;
+    if (url) entry.url = url;
+    return entry;
+  }).filter((value) => !!value);
+}
+async function migrateManifest(options) {
+  const cwd = options.cwd ?? process.cwd();
+  const outFile = options.outFile ?? "featuredrop.manifest.json";
+  const inputPath = path.join(cwd, options.inputFile);
+  const raw = await promises.readFile(inputPath, "utf8");
+  const payload = JSON.parse(raw);
+  const entries = migrateFromSourcePayload(options.from, payload, options.now ?? /* @__PURE__ */ new Date());
+  await promises.writeFile(path.join(cwd, outFile), `${JSON.stringify(entries, null, 2)}
+`, "utf8");
+  return { outFile: path.basename(outFile), entries };
+}
+var dynamicRequire = module$1.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('featuredrop.cjs', document.baseURI).href)));
+var cachedMarked = null;
+var cachedShiki = null;
+function optionalRequire(name) {
+  try {
+    return dynamicRequire(name);
+  } catch (error) {
+    if (error && typeof error === "object" && "code" in error && error.code === "MODULE_NOT_FOUND") {
+      return null;
+    }
+    return null;
+  }
+}
+function getMarked() {
+  if (cachedMarked !== null) return cachedMarked || null;
+  cachedMarked = optionalRequire("marked") ?? false;
+  return cachedMarked || null;
+}
+function getShiki() {
+  if (cachedShiki !== null) return cachedShiki || null;
+  cachedShiki = optionalRequire("shiki") ?? false;
+  return cachedShiki || null;
+}
+function escapeHtml(value) {
+  return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
+}
+function sanitizeUrl(url) {
+  if (!url) return null;
+  const trimmed = url.trim();
+  if (!trimmed) return null;
+  const lower = trimmed.toLowerCase();
+  if (lower.startsWith("javascript:")) return null;
+  if (lower.startsWith("data:")) return null;
+  if (lower.startsWith("vbscript:")) return null;
+  if (/['"<>\s]/.test(trimmed)) return null;
+  return trimmed;
+}
+function sanitizeHtml(html) {
+  return html.replace(/<script[\s\S]*?>[\s\S]*?<\/script>/gi, "").replace(/<style[\s\S]*?>[\s\S]*?<\/style>/gi, "").replace(/\s+on[a-z]+\s*=\s*("[^"]*"|'[^']*'|[^\s>]+)/gi, "").replace(/\s+(?:href|src|xlink:href)\s*=\s*("|')(?:javascript:|data:)[^"']*\1/gi, "");
+}
+function decodeAllowedEntities(html) {
+  const allowTags = [
+    "p",
+    "strong",
+    "em",
+    "a",
+    "code",
+    "pre",
+    "img",
+    "ul",
+    "ol",
+    "li",
+    "blockquote",
+    "h1",
+    "h2",
+    "h3",
+    "h4",
+    "h5",
+    "h6",
+    "br"
+  ];
+  return html.replace(/&lt;(\/?)([a-z0-9]+)([^>]*)&gt;/gi, (match, slash, tag, rest) => {
+    if (!allowTags.includes(tag.toLowerCase())) return match;
+    const decodedRest = rest.replace(/&quot;/g, '"').replace(/&#39;/g, "'").replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">");
+    return `<${slash}${tag}${decodedRest}>`;
+  });
+}
+function renderCodeBlock(code, language) {
+  const shiki = getShiki();
+  if (shiki?.codeToHtml) {
+    try {
+      const rendered = shiki.codeToHtml(code, { lang: language || "text", theme: "github-dark" });
+      if (typeof rendered === "string") return rendered;
+    } catch {
+    }
+  }
+  const langAttr = language ? ` class="language-${escapeHtml(language)}"` : "";
+  return `<pre><code${langAttr}>${escapeHtml(code)}</code></pre>`;
+}
+function inlineMarkdown(text) {
+  let result = escapeHtml(text);
+  const codeSpans = [];
+  result = result.replace(/`([^`]+)`/g, (_match, code) => {
+    const idx = codeSpans.length;
+    codeSpans.push(`<code>${escapeHtml(code)}</code>`);
+    return `\xA7\xA7CODE${idx}\xA7\xA7`;
+  });
+  result = result.replace(/!\[([^\]]*)\]\(([^)]+)\)/g, (_match, alt, url) => {
+    const safeUrl = sanitizeUrl(url);
+    const safeAlt = escapeHtml(alt ?? "");
+    if (!safeUrl) return safeAlt;
+    return `<img src="${escapeHtml(safeUrl)}" alt="${safeAlt}" />`;
+  });
+  result = result.replace(/\[([^\]]+)\]\(([^)]+)\)/g, (_match, label, url) => {
+    const safeUrl = sanitizeUrl(url);
+    const safeLabel = escapeHtml(label ?? "");
+    if (!safeUrl) return safeLabel;
+    return `<a href="${escapeHtml(safeUrl)}" target="_blank" rel="noopener noreferrer">${safeLabel}</a>`;
+  });
+  result = result.replace(/\*\*([^*]+)\*\*/g, "<strong>$1</strong>");
+  result = result.replace(/\*([^*]+)\*/g, "<em>$1</em>");
+  result = result.replace(/§§CODE(\d+)§§/g, (_m, idx) => codeSpans[Number(idx)] ?? "");
+  return result;
+}
+function fallbackParse(markdown) {
+  const lines = markdown.split(/\r?\n/);
+  const blocks = [];
+  let listBuffer = null;
+  let quoteBuffer = null;
+  let inCodeBlock = false;
+  let codeLang;
+  let codeLines = [];
+  const flushList = () => {
+    if (!listBuffer) return;
+    blocks.push(`<ul>${listBuffer.map((item) => `<li>${item}</li>`).join("")}</ul>`);
+    listBuffer = null;
+  };
+  const flushQuote = () => {
+    if (!quoteBuffer) return;
+    const content = quoteBuffer.map((line) => inlineMarkdown(line.trim())).join("<br>");
+    blocks.push(`<blockquote>${content}</blockquote>`);
+    quoteBuffer = null;
+  };
+  const flushCode = () => {
+    if (!inCodeBlock) return;
+    blocks.push(renderCodeBlock(codeLines.join("\n"), codeLang));
+    codeLines = [];
+    codeLang = void 0;
+    inCodeBlock = false;
+  };
+  for (const rawLine of lines) {
+    const line = rawLine.replace(/\s+$/, "");
+    const codeFence = line.match(/^```(.*)$/);
+    if (codeFence) {
+      if (inCodeBlock) {
+        flushCode();
+      } else {
+        flushList();
+        flushQuote();
+        inCodeBlock = true;
+        codeLang = codeFence[1]?.trim() || void 0;
+        codeLines = [];
+      }
+      continue;
+    }
+    if (inCodeBlock) {
+      codeLines.push(rawLine);
+      continue;
+    }
+    const listMatch = line.match(/^\s*[-*+]\s+(.*)$/);
+    if (listMatch) {
+      flushQuote();
+      listBuffer = listBuffer ?? [];
+      listBuffer.push(inlineMarkdown(listMatch[1].trim()));
+      continue;
+    }
+    if (listBuffer) flushList();
+    const headingMatch = line.match(/^(#{1,6})\s+(.*)$/);
+    if (headingMatch) {
+      flushQuote();
+      const level = headingMatch[1].length;
+      const content = inlineMarkdown(headingMatch[2].trim());
+      blocks.push(`<h${level}>${content}</h${level}>`);
+      continue;
+    }
+    const quoteMatch = line.match(/^>\s?(.*)$/);
+    if (quoteMatch) {
+      quoteBuffer = quoteBuffer ?? [];
+      quoteBuffer.push(quoteMatch[1]);
+      continue;
+    }
+    if (quoteBuffer) flushQuote();
+    if (!line.trim()) {
+      continue;
+    }
+    blocks.push(`<p>${inlineMarkdown(line.trim())}</p>`);
+  }
+  flushList();
+  flushQuote();
+  flushCode();
+  return blocks.join("\n");
+}
+function renderWithMarked(markdown, marked) {
+  if (!marked.parse) return null;
+  const renderer = marked.Renderer ? new marked.Renderer() : void 0;
+  if (renderer) {
+    renderer.link = (href, _title, text) => {
+      const safeUrl = sanitizeUrl(href);
+      if (!safeUrl) return escapeHtml(text);
+      return `<a href="${escapeHtml(safeUrl)}" target="_blank" rel="noopener noreferrer">${text}</a>`;
+    };
+    renderer.image = (href, _title, text) => {
+      const safeUrl = sanitizeUrl(href);
+      const safeAlt = escapeHtml(text ?? "");
+      if (!safeUrl) return safeAlt;
+      return `<img src="${escapeHtml(safeUrl)}" alt="${safeAlt}" />`;
+    };
+  }
+  const output = marked.parse(markdown, renderer ? { renderer } : void 0);
+  if (typeof output === "string") return output;
+  return output ? String(output) : null;
+}
+function parseDescription(markdown) {
+  if (!markdown) return "";
+  const marked = getMarked();
+  if (marked) {
+    try {
+      const rendered = renderWithMarked(markdown, marked);
+      if (rendered) {
+        const sanitized2 = sanitizeHtml(rendered);
+        const decoded2 = decodeAllowedEntities(sanitized2);
+        return sanitizeHtml(decoded2);
+      }
+    } catch {
+    }
+  }
+  if (/<[^>]+>/.test(markdown)) {
+    const sanitized2 = sanitizeHtml(markdown);
+    const decoded2 = decodeAllowedEntities(sanitized2);
+    return sanitizeHtml(decoded2);
+  }
+  const fallback = fallbackParse(markdown);
+  const sanitized = sanitizeHtml(fallback);
+  const decoded = decodeAllowedEntities(sanitized);
+  return sanitizeHtml(decoded);
+}
+
+// src/rss.ts
+function escape(str) {
+  return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+function generateRSS(manifest, options) {
+  const title = escape(options?.title ?? "Featuredrop Changelog");
+  const link = escape(options?.link ?? "");
+  const desc = escape(options?.description ?? "Product updates");
+  const items = manifest.slice().sort((a, b) => new Date(b.releasedAt).getTime() - new Date(a.releasedAt).getTime()).map((item) => {
+    const descriptionHtml = item.description ? parseDescription(item.description) : "";
+    const itemLink = item.url ? escape(item.url) : "";
+    return [
+      "<item>",
+      `<title>${escape(item.label)}</title>`,
+      itemLink ? `<link>${itemLink}</link>` : "",
+      `<guid isPermaLink="false">${escape(item.id)}</guid>`,
+      `<pubDate>${new Date(item.releasedAt).toUTCString()}</pubDate>`,
+      `<description><![CDATA[${descriptionHtml}]]></description>`,
+      "</item>"
+    ].join("");
+  }).join("");
+  return [
+    '<?xml version="1.0" encoding="UTF-8"?>',
+    '<rss version="2.0">',
+    "<channel>",
+    `<title>${title}</title>`,
+    link ? `<link>${link}</link>` : "",
+    `<description>${desc}</description>`,
+    items,
+    "</channel>",
+    "</rss>"
+  ].join("");
+}
+
+// src/cli.ts
+function parseArgs(argv) {
+  const [commandRaw, ...rest] = argv;
+  const allowed = /* @__PURE__ */ new Set([
+    "init",
+    "add",
+    "migrate",
+    "build",
+    "validate",
+    "stats",
+    "doctor",
+    "generate-rss",
+    "generate-changelog"
+  ]);
+  const command = allowed.has(commandRaw) ? commandRaw : "help";
+  const parsed = { command };
+  for (let i = 0; i < rest.length; i++) {
+    const arg = rest[i];
+    if (arg === "--pattern") parsed.pattern = rest[++i];
+    else if (arg === "--out") parsed.outFile = rest[++i];
+    else if (arg === "--cwd") parsed.cwd = rest[++i];
+    else if (arg === "--title") parsed.title = rest[++i];
+    else if (arg === "--link") parsed.link = rest[++i];
+    else if (arg === "--description") parsed.description = rest[++i];
+    else if (arg === "--input") parsed.inputFile = rest[++i];
+    else if (arg === "--from") parsed.from = rest[++i];
+    else if (arg === "--format") parsed.format = rest[++i];
+    else if (arg === "--force") parsed.force = true;
+    else if (arg === "--id") parsed.id = rest[++i];
+    else if (arg === "--label") parsed.label = rest[++i];
+    else if (arg === "--type") parsed.type = rest[++i];
+    else if (arg === "--category") parsed.category = rest[++i];
+    else if (arg === "--url") parsed.url = rest[++i];
+    else if (arg === "--releasedAt") parsed.releasedAt = rest[++i];
+    else if (arg === "--showNewUntil") parsed.showNewUntil = rest[++i];
+    else if (arg === "--show-days") parsed.showDays = Number(rest[++i]);
+  }
+  return parsed;
+}
+function printHelp() {
+  console.log("featuredrop CLI");
+  console.log("");
+  console.log("Usage:");
+  console.log("  featuredrop init [--format markdown|json] [--force] [--cwd .]");
+  console.log("  featuredrop add [--label ...] [--id ...] [--description ...] [--type feature|improvement|fix|breaking] [--category ...] [--url ...] [--releasedAt ...] [--showNewUntil ...] [--show-days 14] [--format markdown|json] [--cwd .]");
+  console.log("  featuredrop migrate --from beamer|headway|announcekit|canny|launchnotes [--input export.json] [--out featuredrop.manifest.json] [--cwd .]");
+  console.log("  featuredrop build [--pattern features/**/*.md] [--out featuredrop.manifest.json] [--cwd .]");
+  console.log("  featuredrop validate [--pattern features/**/*.md] [--cwd .]");
+  console.log("  featuredrop stats [--pattern features/**/*.md] [--cwd .]");
+  console.log("  featuredrop doctor [--pattern features/**/*.md] [--cwd .]");
+  console.log("  featuredrop generate-rss [--pattern features/**/*.md] [--out featuredrop.rss.xml] [--title ...] [--link ...] [--description ...] [--cwd .]");
+  console.log("  featuredrop generate-changelog [--pattern features/**/*.md] [--out CHANGELOG.generated.md] [--cwd .]");
+}
+async function promptForLabelIfNeeded(label) {
+  if (label?.trim()) return label.trim();
+  if (!process.stdin.isTTY || !process.stdout.isTTY) {
+    throw new Error("Missing --label. Provide --label in non-interactive mode.");
+  }
+  const rl = promises$1.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  try {
+    const value = (await rl.question("Feature label: ")).trim();
+    if (!value) throw new Error("Feature label is required");
+    return value;
+  } finally {
+    rl.close();
+  }
+}
+async function run() {
+  const args = parseArgs(process.argv.slice(2));
+  if (args.command === "help") {
+    printHelp();
+    process.exitCode = 1;
+    return;
+  }
+  try {
+    if (args.command === "init") {
+      const result = await initFeaturedropProject({
+        cwd: args.cwd,
+        format: args.format,
+        force: args.force
+      });
+      console.log(`Initialized featuredrop project (${result.format})`);
+      for (const path of result.created) {
+        console.log(`- ${path}`);
+      }
+      return;
+    }
+    if (args.command === "add") {
+      const label = await promptForLabelIfNeeded(args.label);
+      const result = await addFeatureEntry({
+        cwd: args.cwd,
+        format: args.format,
+        id: args.id,
+        label,
+        description: args.description,
+        type: args.type,
+        category: args.category,
+        url: args.url,
+        releasedAt: args.releasedAt,
+        showNewUntil: args.showNewUntil,
+        showDays: args.showDays
+      });
+      console.log(`Added feature "${result.entry.id}" -> ${result.path}`);
+      return;
+    }
+    if (args.command === "migrate") {
+      const from = args.from;
+      if (!from) {
+        throw new Error('Missing required "--from" (beamer|headway|announcekit|canny|launchnotes)');
+      }
+      const inputFile = args.inputFile ?? `${from}-export.json`;
+      const result = await migrateManifest({
+        cwd: args.cwd,
+        from,
+        inputFile,
+        outFile: args.outFile
+      });
+      console.log(`Migrated ${result.entries.length} entries from ${from} -> ${result.outFile}`);
+      return;
+    }
+    if (args.command === "build") {
+      const out = args.outFile ?? "featuredrop.manifest.json";
+      const entries2 = await buildManifestFromPattern({
+        pattern: args.pattern,
+        outFile: out,
+        cwd: args.cwd
+      });
+      console.log(`Built ${entries2.length} feature entries -> ${out}`);
+      return;
+    }
+    if (args.command === "validate") {
+      await validateFeatureFiles({
+        pattern: args.pattern,
+        cwd: args.cwd
+      });
+      console.log("Feature files valid");
+      return;
+    }
+    const entries = await buildManifestFromPattern({
+      pattern: args.pattern,
+      cwd: args.cwd
+    });
+    if (args.command === "stats") {
+      const stats = computeManifestStats(entries);
+      console.log(`Total entries: ${stats.total}`);
+      console.log(`By type: ${Object.entries(stats.byType).map(([k, v]) => `${k}=${v}`).join(", ") || "none"}`);
+      console.log(`By category: ${Object.entries(stats.byCategory).map(([k, v]) => `${k}=${v}`).join(", ") || "none"}`);
+      if (stats.newestRelease) console.log(`Newest release: ${stats.newestRelease}`);
+      if (stats.oldestRelease) console.log(`Oldest release: ${stats.oldestRelease}`);
+      return;
+    }
+    if (args.command === "doctor") {
+      const report = runDoctor(entries);
+      for (const check of report.checks) console.log(`\u2713 ${check}`);
+      for (const warning of report.warnings) console.log(`\u26A0 ${warning}`);
+      for (const error of report.errors) console.log(`\u2717 ${error}`);
+      console.log("");
+      console.log(`${report.warnings.length} warning(s), ${report.errors.length} error(s).`);
+      if (report.errors.length > 0) process.exitCode = 1;
+      return;
+    }
+    if (args.command === "generate-rss") {
+      const out = args.outFile ?? "featuredrop.rss.xml";
+      const xml = generateRSS(entries, {
+        title: args.title,
+        link: args.link,
+        description: args.description
+      });
+      await promises.writeFile(path.join(args.cwd ?? process.cwd(), out), `${xml}
+`, "utf8");
+      console.log(`Generated RSS feed -> ${out}`);
+      return;
+    }
+    if (args.command === "generate-changelog") {
+      const out = args.outFile ?? "CHANGELOG.generated.md";
+      const markdown = generateMarkdownChangelog(entries);
+      await promises.writeFile(path.join(args.cwd ?? process.cwd(), out), markdown, "utf8");
+      console.log(`Generated markdown changelog -> ${out}`);
+      return;
+    }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.error(`featuredrop: ${message}`);
+    process.exitCode = 1;
+  }
+}
+void run();
+//# sourceMappingURL=featuredrop.cjs.map
+//# sourceMappingURL=featuredrop.cjs.map