@mergedapp/feature-flags 0.1.3

package/dist/cjs/cli/audit.js

@@ -0,0 +1,117 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.audit = audit;
+const promises_1 = require("node:fs/promises");
+const node_path_1 = require("node:path");
+const config_loader_js_1 = require("./config-loader.js");
+const CODE_EXTENSIONS = new Set([".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"]);
+async function collectFiles(dir) {
+    const files = [];
+    const entries = await (0, promises_1.readdir)(dir, { withFileTypes: true });
+    for (const entry of entries) {
+        const fullPath = (0, node_path_1.join)(dir, entry.name);
+        if (entry.isDirectory()) {
+            if (entry.name === "node_modules" || entry.name === ".git" || entry.name === "dist") {
+                continue;
+            }
+            files.push(...(await collectFiles(fullPath)));
+        }
+        else if (CODE_EXTENSIONS.has((0, node_path_1.extname)(entry.name))) {
+            files.push(fullPath);
+        }
+    }
+    return files;
+}
+async function fetchDefinitions(params) {
+    const url = new URL("/api/feature-flags/definitions", params.apiUrl);
+    url.searchParams.set("organizationId", params.organizationId);
+    const response = await fetch(url.toString(), {
+        headers: { Authorization: `Bearer ${params.clientKey}` },
+    });
+    if (!response.ok) {
+        throw new Error(`Failed to fetch definitions: ${response.status} ${response.statusText}`);
+    }
+    const body = (await response.json());
+    return body.definitions;
+}
+async function audit(args) {
+    const dir = (0, node_path_1.resolve)(args.dir ?? "./src");
+    const loadedConfig = await config_loader_js_1.FeatureFlagCliConfigLoader.load({ configPath: args.config });
+    const config = loadedConfig.config;
+    const apiUrl = args["api-url"] ?? config.apiUrl ?? process.env.FEATURE_FLAG_API_URL;
+    const clientKey = args["client-key"] ?? config.clientKey ?? process.env.FEATURE_FLAG_CLIENT_KEY;
+    const organizationId = args["organization-id"] ?? config.organizationId ?? process.env.FEATURE_FLAG_ORGANIZATION_ID;
+    if (!apiUrl || !clientKey || !organizationId) {
+        throw new Error("Missing --api-url, --client-key, --organization-id, or a discoverable featureflags config.");
+    }
+    console.log(`Fetching flag definitions from ${apiUrl}...`);
+    const definitions = await fetchDefinitions({ apiUrl, clientKey, organizationId });
+    console.log(`Scanning ${dir} for flag references...`);
+    const files = await collectFiles(dir);
+    const flagIdSet = new Set(definitions.map((d) => d.id));
+    const flagCodeKeySet = new Set(definitions.map((d) => d.codeKey));
+    const archivedIds = new Set(definitions.filter((d) => d.isArchived).map((d) => d.id));
+    const referencedIds = new Set();
+    const referencedCodeKeys = new Set();
+    for (const file of files) {
+        const content = await (0, promises_1.readFile)(file, "utf-8");
+        for (const id of flagIdSet) {
+            if (content.includes(id)) {
+                referencedIds.add(id);
+            }
+        }
+        for (const codeKey of flagCodeKeySet) {
+            if (content.includes(`"${codeKey}"`) || content.includes(`'${codeKey}'`)) {
+                referencedCodeKeys.add(codeKey);
+            }
+        }
+    }
+    const codeKeyToDefinition = new Map(definitions.map((d) => [d.codeKey, d]));
+    const allReferenced = new Set();
+    for (const id of referencedIds)
+        allReferenced.add(id);
+    for (const codeKey of referencedCodeKeys) {
+        const def = codeKeyToDefinition.get(codeKey);
+        if (def)
+            allReferenced.add(def.id);
+    }
+    const used = [];
+    const unused = [];
+    const archivedButReferenced = [];
+    for (const def of definitions) {
+        if (allReferenced.has(def.id)) {
+            if (archivedIds.has(def.id)) {
+                archivedButReferenced.push(def);
+            }
+            else {
+                used.push(def);
+            }
+        }
+        else if (!def.isArchived) {
+            unused.push(def);
+        }
+    }
+    console.log("\n--- Feature Flag Audit Report ---\n");
+    if (used.length > 0) {
+        console.log(`Active and referenced (${used.length}):`);
+        for (const d of used) {
+            console.log(`  [OK] ${d.codeKey} (${d.id})`);
+        }
+    }
+    if (unused.length > 0) {
+        console.log(`\nDefined in API but not referenced in code (${unused.length}):`);
+        for (const d of unused) {
+            console.log(`  [UNUSED] ${d.codeKey} (${d.id})`);
+        }
+    }
+    if (archivedButReferenced.length > 0) {
+        console.log(`\nArchived but still referenced in code (${archivedButReferenced.length}):`);
+        for (const d of archivedButReferenced) {
+            console.log(`  [STALE] ${d.codeKey} (${d.id}) — archived, needs cleanup`);
+        }
+    }
+    if (unused.length === 0 && archivedButReferenced.length === 0) {
+        console.log("\nAll flags are clean.");
+    }
+    console.log(`\nScanned ${files.length} files in ${dir}.`);
+}

package/dist/cjs/cli/cleanup.js

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cleanup = cleanup;
+const promises_1 = require("node:fs/promises");
+const node_path_1 = require("node:path");
+const CODE_EXTENSIONS = new Set([".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"]);
+async function collectFiles(dir) {
+    const files = [];
+    const entries = await (0, promises_1.readdir)(dir, { withFileTypes: true });
+    for (const entry of entries) {
+        const fullPath = (0, node_path_1.join)(dir, entry.name);
+        if (entry.isDirectory()) {
+            if (entry.name === "node_modules" || entry.name === ".git" || entry.name === "dist") {
+                continue;
+            }
+            files.push(...(await collectFiles(fullPath)));
+        }
+        else if (CODE_EXTENSIONS.has((0, node_path_1.extname)(entry.name))) {
+            files.push(fullPath);
+        }
+    }
+    return files;
+}
+async function fetchDefinitions(params) {
+    const url = new URL("/api/feature-flags/definitions", params.apiUrl);
+    url.searchParams.set("organizationId", params.organizationId);
+    const response = await fetch(url.toString(), {
+        headers: { Authorization: `Bearer ${params.clientKey}` },
+    });
+    if (!response.ok) {
+        throw new Error(`Failed to fetch definitions: ${response.status} ${response.statusText}`);
+    }
+    const body = (await response.json());
+    return body.definitions;
+}
+async function cleanup(args) {
+    const dir = (0, node_path_1.resolve)(args.dir ?? "./src");
+    const dryRun = "dry-run" in args;
+    const apiUrl = args["api-url"] ?? process.env.FEATURE_FLAG_API_URL;
+    const clientKey = args["client-key"] ?? process.env.FEATURE_FLAG_CLIENT_KEY;
+    const organizationId = args["organization-id"];
+    if (!apiUrl || !clientKey || !organizationId) {
+        throw new Error("Missing --api-url, --client-key, or --organization-id.");
+    }
+    console.log(`Fetching flag definitions from ${apiUrl}...`);
+    const definitions = await fetchDefinitions({ apiUrl, clientKey, organizationId });
+    const archivedFlags = definitions.filter((d) => d.isArchived && d.type === "BOOLEAN");
+    if (archivedFlags.length === 0) {
+        console.log("No archived boolean flags to clean up.");
+        return;
+    }
+    console.log(`Found ${archivedFlags.length} archived boolean flags to scan for.`);
+    console.log(`Scanning ${dir}...`);
+    const files = await collectFiles(dir);
+    let totalReplacements = 0;
+    for (const filePath of files) {
+        let content = await (0, promises_1.readFile)(filePath, "utf-8");
+        let modified = false;
+        for (const flag of archivedFlags) {
+            const result = replaceArchivedFlagChecks({ content, dryRun, filePath, flag });
+            content = result.content;
+            modified ||= result.replacements > 0;
+            totalReplacements += result.replacements;
+        }
+        if (modified && !dryRun) {
+            await (0, promises_1.writeFile)(filePath, content, "utf-8");
+            console.log(`  Updated: ${filePath}`);
+        }
+    }
+    if (totalReplacements === 0) {
+        console.log("No archived flag references found in code.");
+    }
+    else if (dryRun) {
+        console.log(`\n${totalReplacements} replacement(s) would be made. Re-run without --dry-run to apply.`);
+    }
+    else {
+        console.log(`\n${totalReplacements} replacement(s) applied. Run 'merged-ff generate' to update the generated file.`);
+    }
+}
+function escapeRegex(str) {
+    return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function createIsEnabledCallPattern(value) {
+    const target = escapeRegex(value);
+    return new RegExp(String.raw `(?:\b(?:this|[A-Za-z_$][\w$]*)(?:(?:\?\.|\.)[A-Za-z_$][\w$]*)*(?:\?\.|\.))?isEnabled\(["']${target}["']\)`, "g");
+}
+function replaceArchivedFlagChecks(params) {
+    const patterns = [
+        createIsEnabledCallPattern(params.flag.id),
+        createIsEnabledCallPattern(params.flag.codeKey),
+    ];
+    let nextContent = params.content;
+    let replacements = 0;
+    for (const pattern of patterns) {
+        nextContent = nextContent.replace(pattern, (match) => {
+            replacements++;
+            if (params.dryRun) {
+                console.log(`  [DRY RUN] ${params.filePath}: ${match} → false`);
+                return match;
+            }
+            return "false";
+        });
+    }
+    return { content: nextContent, replacements };
+}

package/dist/cjs/cli/config-loader.js

@@ -0,0 +1,102 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FeatureFlagCliConfigLoader = void 0;
+const node_fs_1 = require("node:fs");
+const promises_1 = require("node:fs/promises");
+const node_path_1 = require("node:path");
+const node_url_1 = require("node:url");
+const CONFIG_FILE_NAMES = [
+    "featureflags.config.json",
+    "featureflags.config.js",
+    "featureflags.config.mjs",
+    "featureflags.config.cjs",
+];
+async function load(params) {
+    const cwd = params.cwd ?? process.cwd();
+    if (params.configPath) {
+        const explicitPath = (0, node_path_1.isAbsolute)(params.configPath) ? params.configPath : (0, node_path_1.resolve)(cwd, params.configPath);
+        return loadFile({ configPath: explicitPath });
+    }
+    const discoveredConfigPath = await findNearestConfigPath({ cwd });
+    if (!discoveredConfigPath) {
+        return { config: {}, configPath: null };
+    }
+    return loadFile({ configPath: discoveredConfigPath });
+}
+function resolveConfigRelativePath(params) {
+    if (!params.value) {
+        return undefined;
+    }
+    if ((0, node_path_1.isAbsolute)(params.value) || !params.configPath) {
+        return params.value;
+    }
+    return (0, node_path_1.resolve)((0, node_path_1.dirname)(params.configPath), params.value);
+}
+async function findNearestConfigPath(params) {
+    let currentDirectory = (0, node_path_1.resolve)(params.cwd);
+    while (true) {
+        for (const fileName of CONFIG_FILE_NAMES) {
+            const candidatePath = (0, node_path_1.resolve)(currentDirectory, fileName);
+            if ((0, node_fs_1.existsSync)(candidatePath)) {
+                return candidatePath;
+            }
+        }
+        const parentDirectory = (0, node_path_1.dirname)(currentDirectory);
+        if (parentDirectory === currentDirectory) {
+            return null;
+        }
+        currentDirectory = parentDirectory;
+    }
+}
+async function loadFile(params) {
+    if (params.configPath.endsWith(".json")) {
+        const content = await (0, promises_1.readFile)(params.configPath, "utf-8");
+        return {
+            config: JSON.parse(content),
+            configPath: params.configPath,
+        };
+    }
+    const imported = await Promise.resolve(`${(0, node_url_1.pathToFileURL)(params.configPath).href}`).then(s => __importStar(require(s)));
+    const config = (imported.default ?? imported);
+    if (!config || typeof config !== "object") {
+        return { config: {}, configPath: params.configPath };
+    }
+    return { config, configPath: params.configPath };
+}
+exports.FeatureFlagCliConfigLoader = {
+    load,
+    resolveConfigRelativePath,
+};

package/dist/cjs/cli/generate.js

@@ -0,0 +1,194 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generate = generate;
+const promises_1 = require("node:fs/promises");
+const node_path_1 = require("node:path");
+const config_loader_js_1 = require("./config-loader.js");
+function assertValidCodeKey(codeKey) {
+    if (!/^[a-z][A-Za-z0-9]*$/.test(codeKey)) {
+        throw new Error(`Invalid feature flag codeKey "${codeKey}". Code keys must be lowerCamelCase alphanumeric identifiers.`);
+    }
+}
+function flagTypeToTsType(flagType) {
+    switch (flagType) {
+        case "BOOLEAN":
+            return "boolean";
+        case "STRING":
+            return "string";
+        case "NUMBER":
+            return "number";
+        case "JSON":
+            return "Record<string, unknown>";
+        case "ARRAY":
+            return "unknown[]";
+        default:
+            return "unknown";
+    }
+}
+function escapeJsDoc(str) {
+    return str.replace(/\*\//g, "*\\/").replace(/\n/g, " ");
+}
+async function fetchDefinitions(params) {
+    const url = new URL("/api/feature-flags/definitions", params.apiUrl);
+    url.searchParams.set("organizationId", params.organizationId);
+    if (params.teamId) {
+        url.searchParams.set("teamId", params.teamId);
+    }
+    const response = await fetch(url.toString(), {
+        headers: { Authorization: `Bearer ${params.clientKey}` },
+    });
+    if (!response.ok) {
+        throw new Error(`Failed to fetch definitions: ${response.status} ${response.statusText}`);
+    }
+    const body = (await response.json());
+    return body.definitions;
+}
+function generateCode(definitions) {
+    const activeFlags = definitions.filter((d) => !d.isArchived);
+    if (activeFlags.length === 0) {
+        return `// Auto-generated by @mergedapp/feature-flags. Do not edit.
+// Generated at: ${new Date().toISOString()}
+// No active feature flags found.
+
+import { MergedFeatureFlags } from "@mergedapp/feature-flags"
+import { createTypedHooks } from "@mergedapp/feature-flags/react"
+import type { FeatureFlagClientConfig } from "@mergedapp/feature-flags"
+
+export const FLAGS = {} as const
+
+export interface FlagValues {}
+
+export type FlagName = keyof typeof FLAGS
+
+export function createClient(config: FeatureFlagClientConfig) {
+  return new MergedFeatureFlags<FlagValues>({ ...config, flagIds: FLAGS })
+}
+
+export const { FeatureFlagProvider, FeatureFlag, useFeatureFlag, useFeatureFlags, useFeatureFlagClient, useFeatureFlagStatus } =
+  createTypedHooks<FlagValues>()
+`;
+    }
+    const flagEntries = activeFlags.map((flag) => {
+        assertValidCodeKey(flag.codeKey);
+        const doc = flag.description ? `  /** ${escapeJsDoc(flag.description)} */\n` : "";
+        return { key: flag.codeKey, id: flag.id, type: flag.type, doc };
+    });
+    const flagsConst = flagEntries.map((e) => `${e.doc}  ${e.key}: "${e.id}",`).join("\n");
+    const flagValuesEntries = flagEntries.map((e) => `  ${e.key}: ${flagTypeToTsType(e.type)}`).join("\n");
+    return `// Auto-generated by @mergedapp/feature-flags. Do not edit.
+// Generated at: ${new Date().toISOString()}
+
+import { MergedFeatureFlags } from "@mergedapp/feature-flags"
+import { createTypedHooks } from "@mergedapp/feature-flags/react"
+import type { FeatureFlagClientConfig } from "@mergedapp/feature-flags"
+
+/** Stable flag ID mapping. Names are for readability; IDs are used at runtime. */
+export const FLAGS = {
+${flagsConst}
+} as const
+
+/** Type-safe flag value types inferred from flag definitions. */
+export interface FlagValues {
+${flagValuesEntries}
+}
+
+export type FlagName = keyof typeof FLAGS
+
+/** Create a type-safe client bound to this flag registry. */
+export function createClient(config: FeatureFlagClientConfig) {
+  return new MergedFeatureFlags<FlagValues>({ ...config, flagIds: FLAGS })
+}
+
+/** Pre-typed React hooks, provider, and JSX wrapper bound to this flag registry. */
+export const { FeatureFlagProvider, FeatureFlag, useFeatureFlag, useFeatureFlags, useFeatureFlagClient, useFeatureFlagStatus } =
+  createTypedHooks<FlagValues>()
+`;
+}
+function generateNestCode(params) {
+    return `// Auto-generated by @mergedapp/feature-flags. Do not edit.
+// Generated at: ${new Date().toISOString()}
+
+import {
+  createTypedNestjsBindings,
+  FeatureFlagContext,
+  FeatureFlagsRequestContextStore,
+  FeatureFlagsService,
+  type FeatureFlagContextFactory,
+  type FeatureFlagEvaluationDetails,
+} from "@mergedapp/feature-flags/nestjs"
+import { FLAGS } from "${params.generatedModulePath}"
+import type { FlagValues } from "${params.generatedModulePath}"
+
+export {
+  FeatureFlagContext,
+  FeatureFlagsRequestContextStore,
+  FeatureFlagsService,
+}
+export type {
+  FeatureFlagContextFactory,
+  FeatureFlagEvaluationDetails,
+}
+
+export const { FeatureFlagsModule, RequireFeatureFlag, FeatureFlagGate } =
+  createTypedNestjsBindings<FlagValues>({ flagIds: FLAGS })
+`;
+}
+function resolveNestOutputPath(outputPath) {
+    const extension = (0, node_path_1.extname)(outputPath);
+    if (extension === ".ts") {
+        return outputPath.slice(0, -extension.length) + ".nest.ts";
+    }
+    return `${outputPath}.nest.ts`;
+}
+function resolveRelativeGeneratedModulePath(params) {
+    const mainBaseName = (0, node_path_1.basename)(params.mainOutputPath, (0, node_path_1.extname)(params.mainOutputPath));
+    const nestDirectory = (0, node_path_1.dirname)(params.nestOutputPath);
+    const mainDirectory = (0, node_path_1.dirname)(params.mainOutputPath);
+    if (nestDirectory === mainDirectory) {
+        return `./${mainBaseName}`;
+    }
+    const relativeDirectory = (0, node_path_1.relative)(nestDirectory, mainDirectory);
+    const normalizedDirectory = relativeDirectory.split("\\").join("/");
+    return `${normalizedDirectory.startsWith(".") ? normalizedDirectory : `./${normalizedDirectory}`}/${mainBaseName}`;
+}
+async function generate(args) {
+    const loadedConfig = await config_loader_js_1.FeatureFlagCliConfigLoader.load({ configPath: args.config });
+    const config = loadedConfig.config;
+    const apiUrl = args["api-url"] ?? config.apiUrl ?? process.env.FEATURE_FLAG_API_URL;
+    const clientKey = args["client-key"] ?? config.clientKey ?? process.env.FEATURE_FLAG_CLIENT_KEY;
+    const outputPath = args.output ??
+        config_loader_js_1.FeatureFlagCliConfigLoader.resolveConfigRelativePath({
+            value: config.outputPath,
+            configPath: loadedConfig.configPath,
+        }) ??
+        "./src/generated/feature-flags.ts";
+    const teamId = args["team-id"] ?? config.teamId;
+    const organizationId = args["organization-id"] ?? config.organizationId ?? process.env.FEATURE_FLAG_ORGANIZATION_ID;
+    if (!apiUrl) {
+        throw new Error("Missing --api-url or FEATURE_FLAG_API_URL env var.");
+    }
+    if (!clientKey) {
+        throw new Error("Missing --client-key or FEATURE_FLAG_CLIENT_KEY env var.");
+    }
+    if (!organizationId) {
+        throw new Error("Missing --organization-id, FEATURE_FLAG_ORGANIZATION_ID, or config.organizationId.");
+    }
+    console.log(`Fetching flag definitions from ${apiUrl}...`);
+    const definitions = await fetchDefinitions({ apiUrl, clientKey, organizationId, teamId });
+    console.log(`Found ${definitions.length} flag definitions.`);
+    const code = generateCode(definitions);
+    const resolvedPath = (0, node_path_1.resolve)(outputPath);
+    const resolvedNestPath = resolveNestOutputPath(resolvedPath);
+    const nestCode = generateNestCode({
+        generatedModulePath: resolveRelativeGeneratedModulePath({
+            mainOutputPath: resolvedPath,
+            nestOutputPath: resolvedNestPath,
+        }),
+    });
+    await (0, promises_1.mkdir)((0, node_path_1.dirname)(resolvedPath), { recursive: true });
+    await (0, promises_1.mkdir)((0, node_path_1.dirname)(resolvedNestPath), { recursive: true });
+    await (0, promises_1.writeFile)(resolvedPath, code, "utf-8");
+    await (0, promises_1.writeFile)(resolvedNestPath, nestCode, "utf-8");
+    console.log(`Generated typed flags at ${resolvedPath}`);
+    console.log(`Generated typed NestJS bindings at ${resolvedNestPath}`);
+}

package/dist/cjs/cli/parse-args.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseArgs = parseArgs;
+function parseArgs(args) {
+    const result = {};
+    for (const arg of args) {
+        const keyValueMatch = arg.match(/^--([^=]+)=(.+)$/);
+        if (keyValueMatch) {
+            result[keyValueMatch[1]] = keyValueMatch[2];
+            continue;
+        }
+        const flagMatch = arg.match(/^--(.+)$/);
+        if (flagMatch) {
+            result[flagMatch[1]] = "true";
+        }
+    }
+    return result;
+}

package/dist/cjs/cli.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const generate_js_1 = require("./cli/generate.js");
+const audit_js_1 = require("./cli/audit.js");
+const cleanup_js_1 = require("./cli/cleanup.js");
+const parse_args_js_1 = require("./cli/parse-args.js");
+const [command, ...args] = process.argv.slice(2);
+async function main() {
+    const parsed = (0, parse_args_js_1.parseArgs)(args);
+    switch (command) {
+        case "generate":
+            await (0, generate_js_1.generate)(parsed);
+            break;
+        case "audit":
+            await (0, audit_js_1.audit)(parsed);
+            break;
+        case "cleanup":
+            await (0, cleanup_js_1.cleanup)(parsed);
+            break;
+        default:
+            console.log(`@mergedapp/feature-flags CLI
+
+Usage:
+  merged-ff generate  Generate typed SDK from flag definitions
+  merged-ff audit     Scan codebase for unused/stale flags
+  merged-ff cleanup   Remove stale flag references (interactive)
+
+Options:
+  --api-url=<url>       API base URL
+  --client-key=<key>    API key (or set FEATURE_FLAG_CLIENT_KEY env var)
+  --output=<path>       Output path for generated file (default: ./src/generated/feature-flags.ts)
+  --dir=<path>          Directory to scan (audit/cleanup, default: ./src)
+  --config=<path>       Config file path for generate/audit (default: auto-discover featureflags.config.{json,js,mjs,cjs} from cwd upward)
+  --dry-run             Preview changes without applying (cleanup)
+  --organization-id=<id>  Organization ID (required)
+  --team-id=<id>        Team ID scope`);
+            if (command) {
+                console.error(`\nUnknown command: ${command}`);
+                process.exit(1);
+            }
+    }
+}
+main().catch((error) => {
+    console.error(error instanceof Error ? error.message : error);
+    process.exit(1);
+});