claude-code/scripts/vite-plugin-feature-flags.ts

import type { Plugin } from "rollup";
import { DEFAULT_BUILD_FEATURES } from "./defines.ts";

/**
 * Collect enabled feature flags from defaults + env vars.
 */
export function getEnabledFeatures(): Set<string> {
  const envFeatures = Object.keys(process.env)
    .filter((k) => k.startsWith("FEATURE_"))
    .map((k) => k.replace("FEATURE_", ""));
  return new Set([...DEFAULT_BUILD_FEATURES, ...envFeatures]);
}

// Regex to match feature('FLAG_NAME') calls with string literal arguments
const FEATURE_CALL_RE = /feature\s*\(\s*['"]([\w]+)['"]\s*\)/g;

/**
 * Vite/Rollup plugin that replaces `feature('X')` calls with boolean literals
 * at the transform stage, BEFORE the bundler resolves imports.
 *
 * This approach is necessary because some feature-gated code blocks contain
 * require() calls to files that don't exist (e.g. hunter.js inside
 * feature('REVIEW_ARTIFACT')). The bundler must see these as dead code
 * (`if (false) { ... }`) before attempting import resolution.
 *
 * Also resolves `import { feature } from 'bun:bundle'` as a virtual module
 * to prevent "module not found" errors.
 */
export default function featureFlagsPlugin(): Plugin {
  const features = getEnabledFeatures();

  const virtualModuleId = "bun:bundle";
  const resolvedVirtualModuleId = "\0" + virtualModuleId;

  return {
    name: "feature-flags",

    // Resolve bun:bundle as a virtual module (prevents "module not found")
    resolveId(id) {
      if (id === virtualModuleId) {
        return resolvedVirtualModuleId;
      }
    },

    // Provide a stub export for bun:bundle (unused at runtime after transform)
    load(id) {
      if (id === resolvedVirtualModuleId) {
        return "export function feature(name) { return false; }";
      }
    },

    // Replace feature('X') calls with true/false literals at transform time,
    // and transpile `using` declarations for Node.js compatibility.
    transform(code, id) {
      // Skip node_modules
      if (id.includes("node_modules")) return null;

      let modified = false;

      // 1. Replace feature('X') calls with boolean literals
      let matchCount = 0;
      let transformed = code.replace(FEATURE_CALL_RE, (match, flagName) => {
        matchCount++;
        return features.has(flagName) ? "true" : "false";
      });
      if (matchCount > 0) modified = true;

      // 2. Transpile `using _ = expr;` to `const _ = expr;` for Node.js compat.
      //    Node.js v22 does not support `using` declarations (Explicit Resource Management).
      //    Safe because: SLOW_OPERATION_LOGGING is not enabled, so slowLogging returns
      //    a no-op disposable whose [Symbol.dispose]() is empty.
      if (transformed.includes("using _")) {
        transformed = transformed.replace(/\busing\s+(_\w*)\s*=/g, "const $1 =");
        modified = true;
      }

      if (!modified) return null;

      return { code: transformed, map: null };
    },
  };
}