flaglint 0.0.1 → 0.1.1

package/dist/bin/flaglint.js

@@ -0,0 +1,947 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { Command } from "commander";
+
+// src/commands/scan.ts
+import { writeFile } from "fs/promises";
+import { stat } from "fs/promises";
+import { resolve as resolve2 } from "path";
+import chalk from "chalk";
+import ora from "ora";
+
+// src/scanner/index.ts
+import { readFile } from "fs/promises";
+import { relative } from "path";
+import fg from "fast-glob";
+import { parse } from "@typescript-eslint/typescript-estree";
+var LD_MEMBER_METHODS = /* @__PURE__ */ new Set(["variation", "variationDetail", "allFlags"]);
+var LD_CLIENT_PATTERN = /ld|client/i;
+var LD_HOOKS = /* @__PURE__ */ new Set(["useFlags", "useLDClient"]);
+var STALE_KEY_WORDS = ["old", "deprecated", "legacy", "temp", "tmp", "test", "demo"];
+var STALE_FILE_RE = /\.(test|spec|mock)\.[jt]sx?$/;
+var STALE_PATH_RE = /\/deprecated\/|\/old\/|\/legacy\//;
+var DEFAULT_EXCLUDE = ["**/node_modules/**", "**/dist/**", "**/build/**", "**/.next/**"];
+function extractFlagKey(arg) {
+  if (!arg) return { flagKey: "dynamic", isDynamic: true };
+  if (arg.type === "Literal" && typeof arg.value === "string") {
+    return { flagKey: arg.value, isDynamic: false };
+  }
+  if (arg.type === "TemplateLiteral" && arg.expressions.length === 0) {
+    const cooked = arg.quasis[0]?.value.cooked;
+    if (cooked != null) return { flagKey: cooked, isDynamic: false };
+  }
+  return { flagKey: "dynamic", isDynamic: true };
+}
+function checkStale(flagKey, filePath) {
+  if (STALE_FILE_RE.test(filePath)) return true;
+  if (STALE_PATH_RE.test(filePath)) return true;
+  const lk = flagKey.toLowerCase();
+  return STALE_KEY_WORDS.some((kw) => lk.includes(kw));
+}
+function walk(node, visit) {
+  if (!node || typeof node !== "object") return;
+  visit(node);
+  for (const key of Object.keys(node)) {
+    if (key === "parent") continue;
+    const val = node[key];
+    if (Array.isArray(val)) {
+      for (const item of val) {
+        if (item && typeof item === "object" && "type" in item) {
+          walk(item, visit);
+        }
+      }
+    } else if (val && typeof val === "object" && "type" in val) {
+      walk(val, visit);
+    }
+  }
+}
+function detectUsages(ast, filePath) {
+  const usages = [];
+  walk(ast, (node) => {
+    if (node.type === "CallExpression") {
+      const call = node;
+      const { callee } = call;
+      const loc = call.loc?.start ?? { line: 0, column: 0 };
+      if (callee.type === "MemberExpression" && !callee.computed && callee.object.type === "Identifier" && callee.property.type === "Identifier" && LD_CLIENT_PATTERN.test(callee.object.name) && LD_MEMBER_METHODS.has(callee.property.name)) {
+        const method = callee.property.name;
+        if (method === "allFlags") {
+          usages.push({
+            flagKey: "*",
+            isDynamic: false,
+            file: filePath,
+            line: loc.line,
+            column: loc.column,
+            callType: "allFlags",
+            isStale: checkStale("*", filePath)
+          });
+        } else {
+          const { flagKey, isDynamic } = extractFlagKey(call.arguments[0]);
+          usages.push({
+            flagKey,
+            isDynamic,
+            file: filePath,
+            line: loc.line,
+            column: loc.column,
+            callType: method,
+            isStale: checkStale(flagKey, filePath)
+          });
+        }
+        return;
+      }
+      if (callee.type === "Identifier") {
+        const name = callee.name;
+        if (name === "isFeatureEnabled") {
+          const { flagKey, isDynamic } = extractFlagKey(call.arguments[0]);
+          usages.push({
+            flagKey,
+            isDynamic,
+            file: filePath,
+            line: loc.line,
+            column: loc.column,
+            callType: "isFeatureEnabled",
+            isStale: checkStale(flagKey, filePath)
+          });
+          return;
+        }
+        if (LD_HOOKS.has(name)) {
+          usages.push({
+            flagKey: "*",
+            isDynamic: false,
+            file: filePath,
+            line: loc.line,
+            column: loc.column,
+            callType: name === "useFlags" ? "hook-useFlags" : "hook-useLDClient",
+            isStale: checkStale("*", filePath)
+          });
+          return;
+        }
+      }
+      if (callee.type === "CallExpression" && callee.callee.type === "Identifier" && callee.callee.name === "withLDConsumer") {
+        usages.push({
+          flagKey: "*",
+          isDynamic: false,
+          file: filePath,
+          line: loc.line,
+          column: loc.column,
+          callType: "hoc",
+          isStale: checkStale("*", filePath)
+        });
+        return;
+      }
+    }
+    if (node.type === "JSXOpeningElement") {
+      const jsx = node;
+      if (jsx.name.type === "JSXIdentifier" && jsx.name.name === "LDProvider") {
+        const loc = jsx.loc?.start ?? { line: 0, column: 0 };
+        usages.push({
+          flagKey: "*",
+          isDynamic: false,
+          file: filePath,
+          line: loc.line,
+          column: loc.column,
+          callType: "provider",
+          isStale: false
+        });
+      }
+    }
+  });
+  return usages;
+}
+async function scan(dir, config, onProgress) {
+  const start = Date.now();
+  for (const pattern of config.include) {
+    if (pattern.startsWith("/") || pattern.startsWith("..")) {
+      throw new Error(
+        `Invalid include pattern: "${pattern}" \u2014 patterns must be relative and must not start with ".."`
+      );
+    }
+  }
+  const files = await fg(config.include, {
+    cwd: dir,
+    absolute: true,
+    ignore: [...DEFAULT_EXCLUDE, ...config.exclude],
+    onlyFiles: true
+  });
+  const allUsages = [];
+  const warnings = [];
+  let scannedFiles = 0;
+  for (const file of files) {
+    scannedFiles++;
+    onProgress?.(scannedFiles);
+    let code;
+    try {
+      code = await readFile(file, "utf8");
+    } catch {
+      continue;
+    }
+    let ast;
+    try {
+      ast = parse(code, {
+        jsx: true,
+        loc: true,
+        range: false,
+        comment: false,
+        tokens: false
+      });
+    } catch {
+      warnings.push(`warn: failed to parse ${relative(dir, file)}`);
+      continue;
+    }
+    allUsages.push(...detectUsages(ast, file));
+  }
+  if (config.staleThreshold > 0) {
+    const flagFileCount = /* @__PURE__ */ new Map();
+    for (const usage of allUsages) {
+      if (!usage.isDynamic && usage.flagKey !== "*") {
+        if (!flagFileCount.has(usage.flagKey)) {
+          flagFileCount.set(usage.flagKey, /* @__PURE__ */ new Set());
+        }
+        flagFileCount.get(usage.flagKey).add(usage.file);
+      }
+    }
+    for (const usage of allUsages) {
+      if (!usage.isDynamic && usage.flagKey !== "*") {
+        const fileCount = flagFileCount.get(usage.flagKey)?.size ?? 0;
+        if (fileCount <= config.staleThreshold) {
+          usage.isStale = true;
+        }
+      }
+    }
+  }
+  const uniqueFlags = [
+    ...new Set(
+      allUsages.filter((u) => !u.isDynamic && u.flagKey !== "*").map((u) => u.flagKey)
+    )
+  ];
+  return {
+    scannedFiles,
+    totalUsages: allUsages.length,
+    uniqueFlags,
+    usages: allUsages,
+    scanDurationMs: Date.now() - start,
+    warnings
+  };
+}
+
+// src/reporter/index.ts
+function esc(s) {
+  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+function staleReason(u) {
+  if (/\.(test|spec|mock)\.[jt]sx?$/.test(u.file)) return "Located in test file";
+  if (/\/deprecated\/|\/old\/|\/legacy\//.test(u.file)) return "Located in deprecated path";
+  const kw = ["old", "deprecated", "legacy", "temp", "tmp", "test", "demo"].find(
+    (k) => u.flagKey.toLowerCase().includes(k)
+  );
+  return kw ? `Contains "${kw}" in key` : "Flagged as stale";
+}
+function buildFlagMap(usages) {
+  const map = /* @__PURE__ */ new Map();
+  for (const u of usages) {
+    if (!map.has(u.flagKey)) {
+      map.set(u.flagKey, { usages: [], files: /* @__PURE__ */ new Set(), callTypes: /* @__PURE__ */ new Set(), isStale: false });
+    }
+    const entry = map.get(u.flagKey);
+    entry.usages.push(u);
+    entry.files.add(u.file);
+    entry.callTypes.add(u.callType);
+    if (u.isStale) entry.isStale = true;
+  }
+  return map;
+}
+function sortedFlagEntries(map) {
+  return [...map.entries()].sort(([, a], [, b]) => {
+    if (a.isStale !== b.isStale) return a.isStale ? -1 : 1;
+    return b.usages.length - a.usages.length;
+  });
+}
+function formatMarkdown(result, options) {
+  const { scannedFiles, totalUsages, uniqueFlags, usages, scanDurationMs } = result;
+  const staleUsages = usages.filter((u) => u.isStale);
+  const dynamicUsages = usages.filter((u) => u.isDynamic);
+  const flagMap = buildFlagMap(usages);
+  const sorted = sortedFlagEntries(flagMap);
+  const staleFlags = sorted.filter(([, d]) => d.isStale);
+  const lines = [];
+  lines.push("# FlagLint Scan Report");
+  if (options.title) lines.push("", options.title);
+  lines.push("");
+  lines.push(`**Scanned:** ${scannedFiles} files in ${scanDurationMs}ms  `);
+  lines.push(`**Flag usages:** ${totalUsages} across ${uniqueFlags.length} unique flags  `);
+  lines.push(`**Stale candidates:** ${staleUsages.length} flags flagged for review`);
+  lines.push("");
+  lines.push("## Flag Inventory");
+  lines.push("| Flag Key | Usages | Files | Call Types | Status |");
+  lines.push("|----------|--------|-------|------------|--------|");
+  for (const [key, data] of sorted) {
+    const status = data.isStale ? "\u26A0 Stale" : "\u2713 Active";
+    lines.push(
+      `| ${key} | ${data.usages.length} | ${data.files.size} | ${[...data.callTypes].join(", ")} | ${status} |`
+    );
+  }
+  lines.push("");
+  lines.push("## Usages by File");
+  const byFile = /* @__PURE__ */ new Map();
+  for (const u of usages) {
+    if (!byFile.has(u.file)) byFile.set(u.file, []);
+    byFile.get(u.file).push(u);
+  }
+  for (const [file, fileUsages] of byFile) {
+    lines.push(`### ${file}`);
+    for (const u of [...fileUsages].sort((a, b) => a.line - b.line)) {
+      lines.push(`- Line ${u.line}: \`${u.flagKey}\` (${u.callType})`);
+    }
+    lines.push("");
+  }
+  if (staleFlags.length > 0) {
+    lines.push("## \u26A0 Stale Flag Candidates");
+    lines.push("Flags that may be safe to remove:");
+    lines.push("| Flag Key | Reason | Location |");
+    lines.push("|----------|--------|----------|");
+    for (const [key, data] of staleFlags) {
+      const first = data.usages[0];
+      lines.push(`| ${key} | ${staleReason(first)} | ${first.file}:${first.line} |`);
+    }
+    lines.push("");
+  }
+  if (dynamicUsages.length > 0) {
+    lines.push("## Dynamic Flag Keys (Manual Review Required)");
+    lines.push(
+      "Flags with non-static keys that could not be automatically identified:"
+    );
+    for (const u of dynamicUsages) {
+      lines.push(`- \`dynamic\` at ${u.file}:${u.line} \u2014 key determined at runtime`);
+    }
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+function formatJSON(result) {
+  return JSON.stringify({ generatedAt: (/* @__PURE__ */ new Date()).toISOString(), ...result }, null, 2);
+}
+function formatHTML(result, options) {
+  const { scannedFiles, totalUsages, uniqueFlags, usages, scanDurationMs } = result;
+  const staleCount = usages.filter((u) => u.isStale).length;
+  const dynamicCount = usages.filter((u) => u.isDynamic).length;
+  const date = (/* @__PURE__ */ new Date()).toLocaleString();
+  const flagMap = buildFlagMap(usages);
+  const sorted = sortedFlagEntries(flagMap);
+  const rows = sorted.map(([key, data]) => {
+    const cls = data.isStale ? "stale" : data.usages.some((u) => u.isDynamic) ? "dynamic" : "";
+    const status = data.isStale ? "\u26A0 Stale" : "\u2713 Active";
+    const fileList = [...data.files].map((f) => esc(f)).join("<br>");
+    return `<tr class="${cls}"><td><code>${esc(key)}</code></td><td>${data.usages.length}</td><td>${fileList}</td><td>${[...data.callTypes].map(esc).join(", ")}</td><td>${status}</td></tr>`;
+  }).join("\n      ");
+  const title = options.title ? esc(options.title) : "FlagLint Scan Report";
+  const version = true ? "0.1.1" : "0.1.0";
+  return `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>${title}</title>
+  <style>
+    :root{--bg:#fff;--surface:#f8f9fa;--border:#dee2e6;--text:#212529;--muted:#6c757d;--stale-bg:#fef3c7;--dyn-bg:#dbeafe;--card-shadow:0 1px 3px rgba(0,0,0,.1)}
+    @media(prefers-color-scheme:dark){:root{--bg:#0f172a;--surface:#1e293b;--border:#334155;--text:#e2e8f0;--muted:#94a3b8;--stale-bg:#78350f;--dyn-bg:#1e3a5f;--card-shadow:0 1px 3px rgba(0,0,0,.4)}}
+    *{box-sizing:border-box;margin:0;padding:0}
+    body{background:var(--bg);color:var(--text);font-family:system-ui,-apple-system,sans-serif;padding:2rem;max-width:1200px;margin:0 auto;line-height:1.5}
+    h1{font-size:1.75rem;margin-bottom:.25rem}
+    h2{font-size:1.125rem;margin:2rem 0 .75rem;padding-bottom:.5rem;border-bottom:1px solid var(--border)}
+    .subtitle{color:var(--muted);margin-bottom:1.5rem;font-size:.875rem}
+    .cards{display:flex;gap:1rem;flex-wrap:wrap;margin-bottom:2rem}
+    .card{flex:1;min-width:140px;background:var(--surface);border:1px solid var(--border);border-radius:8px;padding:1rem;box-shadow:var(--card-shadow)}
+    .card-num{font-size:1.875rem;font-weight:700;line-height:1}
+    .card-num.yellow{color:#d97706}
+    .card-num.blue{color:#3b82f6}
+    .card-label{color:var(--muted);font-size:.75rem;margin-top:.375rem;text-transform:uppercase;letter-spacing:.05em}
+    .filter-wrap{margin-bottom:.75rem}
+    #filter{width:100%;padding:.5rem .75rem;border:1px solid var(--border);border-radius:6px;background:var(--surface);color:var(--text);font-size:.875rem;outline:none}
+    #filter:focus{border-color:#6366f1}
+    table{width:100%;border-collapse:collapse;font-size:.8125rem}
+    th{text-align:left;padding:.625rem .75rem;background:var(--surface);border-bottom:2px solid var(--border);font-weight:600;white-space:nowrap}
+    td{padding:.625rem .75rem;border-bottom:1px solid var(--border);vertical-align:top}
+    tr.stale td{background:var(--stale-bg)}
+    tr.dynamic td{background:var(--dyn-bg)}
+    code{font-family:ui-monospace,monospace;font-size:.8em;background:var(--surface);padding:.1em .3em;border-radius:3px}
+    footer{margin-top:3rem;padding-top:1rem;border-top:1px solid var(--border);color:var(--muted);font-size:.75rem;text-align:center}
+  </style>
+</head>
+<body>
+  <h1>${title}</h1>
+  <p class="subtitle">Scanned ${scannedFiles} files in ${scanDurationMs}ms</p>
+
+  <div class="cards">
+    <div class="card"><div class="card-num">${scannedFiles}</div><div class="card-label">Files Scanned</div></div>
+    <div class="card"><div class="card-num">${uniqueFlags.length}</div><div class="card-label">Unique Flags</div></div>
+    <div class="card"><div class="card-num">${totalUsages}</div><div class="card-label">Total Usages</div></div>
+    <div class="card"><div class="card-num yellow">${staleCount}</div><div class="card-label">Stale Candidates</div></div>
+    <div class="card"><div class="card-num blue">${dynamicCount}</div><div class="card-label">Dynamic Keys</div></div>
+  </div>
+
+  <h2>Flag Inventory</h2>
+  <div class="filter-wrap">
+    <input type="text" id="filter" placeholder="Filter by flag key, file, or call type\u2026">
+  </div>
+  <table id="flags-table">
+    <thead><tr><th>Flag Key</th><th>Usages</th><th>Files</th><th>Call Types</th><th>Status</th></tr></thead>
+    <tbody>
+      ${rows}
+    </tbody>
+  </table>
+
+  <footer>Generated by FlagLint ${esc(version)} on ${esc(date)}</footer>
+
+  <script>
+    const input = document.getElementById('filter');
+    const rows = document.querySelectorAll('#flags-table tbody tr');
+    input.addEventListener('input', () => {
+      const q = input.value.toLowerCase();
+      rows.forEach(r => { r.style.display = r.textContent.toLowerCase().includes(q) ? '' : 'none'; });
+    });
+  </script>
+</body>
+</html>`;
+}
+function formatReport(result, options) {
+  switch (options.format) {
+    case "json":
+      return formatJSON(result);
+    case "html":
+      return formatHTML(result, options);
+    default:
+      return formatMarkdown(result, options);
+  }
+}
+
+// src/config.ts
+import { existsSync, readFileSync } from "fs";
+import { resolve } from "path";
+import { z, ZodError } from "zod";
+var FlagLintConfigSchema = z.object({
+  include: z.array(z.string()).default(["**/*.{ts,tsx,js,jsx}"]),
+  exclude: z.array(z.string()).default([
+    "**/node_modules/**",
+    "**/dist/**",
+    "**/build/**",
+    "**/.next/**",
+    "**/coverage/**",
+    "**/*.d.ts"
+  ]),
+  provider: z.enum(["launchdarkly", "unleash", "growthbook", "custom"]).default("launchdarkly"),
+  staleThreshold: z.number().int().min(0).default(1),
+  reportTitle: z.string().optional(),
+  outputDir: z.string().default(".")
+});
+var SEARCH_PATHS = [".flaglintrc", ".flaglintrc.json", "flaglint.config.json"];
+function loadConfig(configPath) {
+  const candidates = configPath ? [configPath] : SEARCH_PATHS;
+  for (const candidate of candidates) {
+    const full = resolve(candidate);
+    if (!existsSync(full)) continue;
+    let raw;
+    try {
+      raw = JSON.parse(readFileSync(full, "utf8"));
+    } catch (err) {
+      throw new Error(`Error reading ${candidate}: ${String(err)}`);
+    }
+    try {
+      return FlagLintConfigSchema.parse(raw);
+    } catch (err) {
+      if (err instanceof ZodError) {
+        const detail = err.errors.map((e) => `${e.path.join(".")}: ${e.message}`).join("; ");
+        throw new Error(`Error in ${candidate}: ${detail}`);
+      }
+      throw err;
+    }
+  }
+  return FlagLintConfigSchema.parse({});
+}
+
+// src/commands/scan.ts
+var VALID_FORMATS = ["json", "markdown", "html"];
+function registerScanCommand(program2) {
+  program2.command("scan").description("Scan a directory for feature flag usages and detect stale flags").argument("[dir]", "directory to scan", process.cwd()).option("-f, --format <format>", "output format: json | markdown | html", "markdown").option("-o, --output <file>", "write report to file").option("-c, --config <path>", "path to .flaglintrc config file").addHelpText(
+    "after",
+    `
+Examples:
+  $ flaglint scan                    scan current directory
+  $ flaglint scan ./src              scan specific directory
+  $ flaglint scan --format json      output as JSON
+  $ flaglint scan --output report.md save to file`
+  ).action(
+    async (dir, options) => {
+      if (!VALID_FORMATS.includes(options.format)) {
+        process.stderr.write(
+          chalk.red(
+            `Error: Invalid format '${options.format}'. Must be one of: ${VALID_FORMATS.join(", ")}
+`
+          )
+        );
+        process.exit(2);
+      }
+      try {
+        const s = await stat(resolve2(dir));
+        if (!s.isDirectory()) {
+          process.stderr.write(chalk.red(`Error: Not a directory: ${dir}
+`));
+          process.exit(1);
+        }
+      } catch (err) {
+        const code = err.code;
+        if (code === "ENOENT") {
+          process.stderr.write(chalk.red(`Error: Directory not found: ${dir}
+`));
+        } else if (code === "EACCES") {
+          process.stderr.write(chalk.red(`Error: Permission denied: ${dir}
+`));
+        } else {
+          process.stderr.write(chalk.red(`Error: Cannot access directory: ${dir}
+`));
+        }
+        process.exit(1);
+      }
+      let config;
+      try {
+        config = loadConfig(options.config);
+      } catch (err) {
+        process.stderr.write(chalk.red(String(err instanceof Error ? err.message : err)) + "\n");
+        process.exit(1);
+      }
+      const format = options.format;
+      const spinner = ora(`Scanning ${dir}...`).start();
+      process.once("SIGINT", () => {
+        spinner.stop();
+        process.exit(130);
+      });
+      let lastSpinnerUpdate = 0;
+      let result;
+      try {
+        result = await scan(dir, config, (filesScanned) => {
+          if (filesScanned - lastSpinnerUpdate >= 50) {
+            spinner.text = `Scanning... (${filesScanned} files)`;
+            lastSpinnerUpdate = filesScanned;
+          }
+        });
+        spinner.stop();
+      } catch (err) {
+        spinner.fail("Scan failed");
+        process.stderr.write(chalk.red(String(err)) + "\n");
+        process.exit(1);
+      }
+      for (const w of result.warnings) {
+        process.stderr.write(chalk.yellow(w + "\n"));
+      }
+      if (result.scannedFiles === 0) {
+        process.stderr.write(
+          chalk.yellow("No matching files found. Check your .flaglintrc include patterns.\n")
+        );
+        process.exit(0);
+      }
+      if (result.totalUsages === 0) {
+        process.stderr.write(
+          chalk.dim(
+            `No LaunchDarkly SDK usage detected in ${result.scannedFiles} files.
+`
+          )
+        );
+        process.exit(0);
+      }
+      const staleCount = new Set(result.usages.filter((u) => u.isStale).map((u) => u.flagKey)).size;
+      const dynamicCount = new Set(result.usages.filter((u) => u.isDynamic).map((u) => u.flagKey)).size;
+      process.stderr.write(
+        chalk.green(
+          `\u2713 ${result.totalUsages} flag usages found across ${result.uniqueFlags.length} unique flags (${result.scanDurationMs}ms)
+`
+        )
+      );
+      if (staleCount > 0) {
+        process.stderr.write(
+          chalk.yellow(`\u26A0  ${staleCount} potentially stale flag(s) \u2014 review recommended
+`)
+        );
+      }
+      if (dynamicCount > 0) {
+        process.stderr.write(
+          chalk.blue(`\u2139  ${dynamicCount} dynamic flag key(s) require manual review
+`)
+        );
+      }
+      const report = formatReport(result, { format, title: config.reportTitle });
+      if (options.output) {
+        const outPath = resolve2(options.output);
+        try {
+          await writeFile(outPath, report, "utf8");
+          process.stderr.write(chalk.dim(`   Report written to ${options.output}
+`));
+        } catch (err) {
+          process.stderr.write(
+            chalk.red(
+              `Error: Failed to write report to ${options.output}: ${err instanceof Error ? err.message : String(err)}
+`
+            )
+          );
+          process.exit(1);
+        }
+      } else {
+        process.stdout.write(report + "\n");
+      }
+      process.exit(staleCount > 0 ? 1 : 0);
+    }
+  );
+}
+
+// src/commands/migrate.ts
+import { writeFile as writeFile2 } from "fs/promises";
+import { stat as stat2 } from "fs/promises";
+import { resolve as resolve3 } from "path";
+import chalk2 from "chalk";
+import ora2 from "ora";
+
+// src/migrator/index.ts
+function keyLiteral(usage) {
+  return usage.isDynamic ? "flagKey" : `'${usage.flagKey}'`;
+}
+function buildItem(usage) {
+  const k = keyLiteral(usage);
+  if (usage.isDynamic) {
+    return {
+      usage,
+      openFeatureEquivalent: "client.getBooleanValue()",
+      codeChangeBefore: `ldClient.variation(flagKey, context, false)`,
+      codeChangeAfter: `await client.getBooleanValue(flagKey, false) // server SDK is async`,
+      requiresManualReview: true,
+      reviewReason: "Flag key determined at runtime; OpenFeature server SDK methods are async \u2014 add await and make the enclosing function async"
+    };
+  }
+  switch (usage.callType) {
+    case "variation":
+      return {
+        usage,
+        openFeatureEquivalent: "client.getBooleanValue()",
+        codeChangeBefore: `ldClient.variation(${k}, context, false)`,
+        codeChangeAfter: `await client.getBooleanValue(${k}, false) // server SDK is async`,
+        requiresManualReview: true,
+        reviewReason: "OpenFeature server SDK methods are async \u2014 add await and make the enclosing function async"
+      };
+    case "variationDetail":
+      return {
+        usage,
+        openFeatureEquivalent: "client.getBooleanDetails()",
+        codeChangeBefore: `ldClient.variationDetail(${k}, context, false)`,
+        codeChangeAfter: `await client.getBooleanDetails(${k}, false) // server SDK is async`,
+        requiresManualReview: true,
+        reviewReason: "OpenFeature server SDK methods are async \u2014 add await and make the enclosing function async"
+      };
+    case "allFlags":
+      return {
+        usage,
+        openFeatureEquivalent: null,
+        codeChangeBefore: `ldClient.allFlags(context)`,
+        codeChangeAfter: `// No direct OpenFeature equivalent \u2014 requires manual implementation`,
+        requiresManualReview: true,
+        reviewReason: "allFlags() has no direct OpenFeature equivalent"
+      };
+    case "isFeatureEnabled":
+      return {
+        usage,
+        openFeatureEquivalent: "client.getBooleanValue()",
+        codeChangeBefore: `isFeatureEnabled(${k}, context)`,
+        codeChangeAfter: `await client.getBooleanValue(${k}, false) // server SDK is async`,
+        requiresManualReview: true,
+        reviewReason: "OpenFeature server SDK methods are async \u2014 add await and make the enclosing function async"
+      };
+    case "hook-useFlags":
+      return {
+        usage,
+        openFeatureEquivalent: "useBooleanFlagValue()",
+        codeChangeBefore: `const flags = useFlags()`,
+        codeChangeAfter: `const flagValue = useBooleanFlagValue('your-flag-key', false) // TODO: one hook call per flag`,
+        requiresManualReview: true,
+        reviewReason: "useFlags() returns all flags; OpenFeature requires one useBooleanFlagValue() call per flag"
+      };
+    case "hook-useLDClient":
+      return {
+        usage,
+        openFeatureEquivalent: "useOpenFeatureClient()",
+        codeChangeBefore: `const client = useLDClient()`,
+        codeChangeAfter: `const client = useOpenFeatureClient()`,
+        requiresManualReview: false
+      };
+    case "hoc":
+      return {
+        usage,
+        openFeatureEquivalent: null,
+        codeChangeBefore: `withLDConsumer()(Component)`,
+        codeChangeAfter: `// withOpenFeature() does not exist in OpenFeature SDK 0.4+
+// Convert to a functional component and use useBooleanFlagValue() instead`,
+        requiresManualReview: true,
+        reviewReason: "withOpenFeature() HOC does not exist in OpenFeature SDK 0.4+; convert to a functional component with hooks"
+      };
+    case "provider":
+      return {
+        usage,
+        openFeatureEquivalent: "OpenFeatureProvider",
+        codeChangeBefore: `<LDProvider clientSideID="...">`,
+        codeChangeAfter: `<OpenFeatureProvider provider={...}>`,
+        requiresManualReview: false
+      };
+    default:
+      return {
+        usage,
+        openFeatureEquivalent: null,
+        codeChangeBefore: `// ${usage.callType} call`,
+        codeChangeAfter: `// Manual migration required`,
+        requiresManualReview: true,
+        reviewReason: `Unrecognized call type: ${usage.callType}`
+      };
+  }
+}
+function calcReadinessScore(usages) {
+  let score = 100;
+  const dynamicCount = usages.filter((u) => u.isDynamic).length;
+  score -= Math.min(dynamicCount * 10, 40);
+  const useFlagsCount = usages.filter((u) => u.callType === "hook-useFlags").length;
+  score -= useFlagsCount * 5;
+  const hasAllFlags = usages.some((u) => u.callType === "allFlags");
+  if (hasAllFlags) score -= 15;
+  const hocCount = usages.filter((u) => u.callType === "hoc").length;
+  score -= hocCount * 5;
+  const hasStaticKeys = usages.some((u) => !u.isDynamic && u.flagKey !== "*");
+  if (!hasStaticKeys) score -= 20;
+  return Math.max(0, score);
+}
+function calcRequiredPackages(usages) {
+  const REACT_CALL_TYPES = ["hook-useFlags", "hook-useLDClient", "hoc", "provider"];
+  const SERVER_CALL_TYPES = ["variation", "variationDetail", "allFlags", "isFeatureEnabled"];
+  const hasReactUsage = usages.some((u) => REACT_CALL_TYPES.includes(u.callType));
+  const hasServerUsage = usages.some((u) => SERVER_CALL_TYPES.includes(u.callType));
+  const pkgs = /* @__PURE__ */ new Set();
+  if (hasReactUsage && !hasServerUsage) {
+    pkgs.add("@openfeature/web-sdk");
+    pkgs.add("@openfeature/react-sdk");
+  } else if (hasReactUsage && hasServerUsage) {
+    pkgs.add("@openfeature/server-sdk");
+    pkgs.add("@openfeature/web-sdk");
+    pkgs.add("@openfeature/react-sdk");
+  } else {
+    pkgs.add("@openfeature/server-sdk");
+  }
+  return [...pkgs].sort();
+}
+function analyze(result) {
+  const items = result.usages.map(buildItem);
+  const readinessScore = calcReadinessScore(result.usages);
+  const requiredPackages = calcRequiredPackages(result.usages);
+  const manualReviewCount = items.filter((i) => i.requiresManualReview).length;
+  const autoMigrateCount = items.filter((i) => !i.requiresManualReview).length;
+  return { readinessScore, requiredPackages, items, manualReviewCount, autoMigrateCount };
+}
+function formatMigrationReport(analysis) {
+  const { readinessScore, requiredPackages, items, manualReviewCount, autoMigrateCount } = analysis;
+  const date = (/* @__PURE__ */ new Date()).toLocaleDateString();
+  const version = true ? "0.1.1" : "0.1.0";
+  let scoreLabel;
+  if (readinessScore >= 80) scoreLabel = "\u2713 Your codebase is ready for migration";
+  else if (readinessScore >= 50) scoreLabel = "\u26A0 Some manual work required before migration";
+  else scoreLabel = "\u2717 Significant refactoring needed";
+  const lines = [];
+  lines.push(`# OpenFeature Migration Plan`);
+  lines.push(`Generated by FlagLint v${version} on ${date}`);
+  lines.push("");
+  lines.push(`## Migration Readiness Score: ${readinessScore}/100`);
+  lines.push(scoreLabel);
+  lines.push("");
+  lines.push(`**Auto-migratable:** ${autoMigrateCount} usages  `);
+  lines.push(`**Requires manual review:** ${manualReviewCount} usages`);
+  lines.push("");
+  lines.push("## Required Packages");
+  lines.push("```");
+  lines.push(`npm install ${requiredPackages.join(" ")}`);
+  lines.push("```");
+  lines.push("");
+  lines.push("## Step-by-Step Checklist");
+  lines.push("- [ ] Install OpenFeature packages");
+  lines.push("- [ ] Configure your OpenFeature provider (LaunchDarkly, Unleash, etc.)");
+  lines.push("- [ ] Replace LDProvider with OpenFeatureProvider");
+  lines.push("- [ ] Update each flag evaluation call (see below)");
+  lines.push("- [ ] Remove LaunchDarkly SDK dependency");
+  lines.push("- [ ] Test all flagged features");
+  lines.push("");
+  const autoItems = items.filter((i) => !i.requiresManualReview);
+  const manualItems = items.filter((i) => i.requiresManualReview);
+  if (autoItems.length > 0) {
+    lines.push("## Code Changes Required");
+    for (const item of autoItems) {
+      const { usage } = item;
+      lines.push(`### ${usage.file}:${usage.line} \u2014 \`${usage.flagKey}\``);
+      lines.push("**Before:**");
+      lines.push("```typescript");
+      lines.push(item.codeChangeBefore);
+      lines.push("```");
+      lines.push("**After:**");
+      lines.push("```typescript");
+      lines.push(item.codeChangeAfter);
+      lines.push("```");
+      lines.push("");
+    }
+  }
+  if (manualItems.length > 0) {
+    lines.push("## Manual Review Required");
+    for (const item of manualItems) {
+      const { usage } = item;
+      lines.push(`### ${usage.file}:${usage.line} \u2014 \`${usage.flagKey}\``);
+      if (item.reviewReason) lines.push(`> ${item.reviewReason}`);
+      lines.push("**Before:**");
+      lines.push("```typescript");
+      lines.push(item.codeChangeBefore);
+      lines.push("```");
+      lines.push("**After:**");
+      lines.push("```typescript");
+      lines.push(item.codeChangeAfter);
+      lines.push("```");
+      lines.push("");
+    }
+  }
+  lines.push("## Resources");
+  lines.push("- OpenFeature docs: https://openfeature.dev/docs");
+  lines.push(
+    "- OpenFeature React SDK: https://openfeature.dev/docs/reference/technologies/client/web/react"
+  );
+  lines.push("");
+  return lines.join("\n");
+}
+
+// src/commands/migrate.ts
+function registerMigrateCommand(program2) {
+  program2.command("migrate").description("Analyze migration readiness and generate an OpenFeature migration plan").argument("[dir]", "directory to analyze", process.cwd()).option("-o, --output <file>", "write migration plan to file", "MIGRATION.md").option("-c, --config <path>", "path to .flaglintrc config file").option("--dry-run", "print migration plan to stdout without writing file").addHelpText(
+    "after",
+    `
+Examples:
+  $ flaglint migrate                 generate migration plan for current directory
+  $ flaglint migrate ./src           analyze specific directory
+  $ flaglint migrate --dry-run       preview without writing file
+  $ flaglint migrate --output plan.md write to custom file`
+  ).action(
+    async (dir, options) => {
+      try {
+        const s = await stat2(resolve3(dir));
+        if (!s.isDirectory()) {
+          process.stderr.write(chalk2.red(`Error: Not a directory: ${dir}
+`));
+          process.exit(1);
+        }
+      } catch (err) {
+        const code = err.code;
+        if (code === "ENOENT") {
+          process.stderr.write(chalk2.red(`Error: Directory not found: ${dir}
+`));
+        } else if (code === "EACCES") {
+          process.stderr.write(chalk2.red(`Error: Permission denied: ${dir}
+`));
+        } else {
+          process.stderr.write(chalk2.red(`Error: Cannot access directory: ${dir}
+`));
+        }
+        process.exit(1);
+      }
+      let config;
+      try {
+        config = loadConfig(options.config);
+      } catch (err) {
+        process.stderr.write(chalk2.red(String(err instanceof Error ? err.message : err)) + "\n");
+        process.exit(1);
+      }
+      const spinner = ora2(`Scanning ${dir}...`).start();
+      process.once("SIGINT", () => {
+        spinner.stop();
+        process.exit(130);
+      });
+      let scanResult;
+      try {
+        scanResult = await scan(dir, config);
+        spinner.text = "Analyzing migration readiness...";
+      } catch (err) {
+        spinner.fail("Scan failed");
+        process.stderr.write(chalk2.red(String(err)) + "\n");
+        process.exit(1);
+      }
+      if (scanResult.scannedFiles === 0) {
+        spinner.stop();
+        process.stderr.write(
+          chalk2.yellow("No matching files found. Check your .flaglintrc include patterns.\n")
+        );
+        process.exit(0);
+      }
+      if (scanResult.totalUsages === 0) {
+        spinner.stop();
+        process.stderr.write(
+          chalk2.dim(
+            `No LaunchDarkly SDK usage detected in ${scanResult.scannedFiles} files.
+`
+          )
+        );
+        process.exit(0);
+      }
+      const analysis = analyze(scanResult);
+      spinner.stop();
+      for (const w of scanResult.warnings) {
+        process.stderr.write(chalk2.yellow(w + "\n"));
+      }
+      const { readinessScore } = analysis;
+      const scoreColor = readinessScore >= 80 ? chalk2.green : readinessScore >= 50 ? chalk2.yellow : chalk2.red;
+      process.stderr.write(scoreColor(`Migration Readiness Score: ${readinessScore}/100
+`));
+      process.stderr.write(
+        chalk2.gray(
+          `Auto-migratable: ${analysis.autoMigrateCount} \xB7 Manual review: ${analysis.manualReviewCount}
+`
+        )
+      );
+      const report = formatMigrationReport(analysis);
+      if (options.dryRun) {
+        process.stdout.write(report + "\n");
+        process.exit(0);
+      }
+      const outPath = resolve3(options.output);
+      try {
+        await writeFile2(outPath, report, "utf8");
+        process.stderr.write(chalk2.green(`Migration plan written to ${options.output}
+`));
+      } catch (err) {
+        process.stderr.write(
+          chalk2.red(
+            `Error: Failed to write migration plan to ${options.output}: ${err instanceof Error ? err.message : String(err)}
+`
+          )
+        );
+        process.exit(1);
+      }
+      process.exit(0);
+    }
+  );
+}
+
+// src/cli.ts
+function createCLI() {
+  const program2 = new Command();
+  program2.name("flaglint").description("Find stale feature flags. Detect flag debt. Plan your OpenFeature migration.").version("0.1.1", "-v, --version", "output the current version").addHelpText(
+    "after",
+    `
+Examples:
+  $ flaglint scan                    scan current directory
+  $ flaglint scan ./src              scan specific directory
+  $ flaglint scan --format json      output as JSON
+  $ flaglint scan --output report.md save to file
+  $ flaglint migrate                 generate migration plan
+  $ flaglint migrate --dry-run       preview without writing`
+  );
+  registerScanCommand(program2);
+  registerMigrateCommand(program2);
+  return program2;
+}
+
+// bin/flaglint.ts
+var program = createCLI();
+program.parse(process.argv);
+//# sourceMappingURL=flaglint.js.map