@ebrindley/build 0.0.0-stage → 1.42.1-rc28

package/dist/chunk-W4BAIQ6L.js

@@ -0,0 +1,1212 @@
+import {
+  atomicWrite
+} from "./chunk-4UMRUFBD.js";
+import {
+  redactSensitiveConfig
+} from "./chunk-3M57DADF.js";
+import {
+  autoFixConfig,
+  isFirstTimeDefaultsInitialized,
+  registryErrorAtPath,
+  validateBuildConfig
+} from "./chunk-HT5OCGKN.js";
+import {
+  mergeConfigSources
+} from "./chunk-U5KS22IN.js";
+import {
+  resolveConfig
+} from "./chunk-C3DH3NCY.js";
+import {
+  getActiveProfilePath,
+  loadAllConfigSources,
+  loadProjectConfig,
+  loadUserConfig
+} from "./chunk-M4BUEXXF.js";
+import {
+  mutateUserState,
+  readUserState
+} from "./chunk-ZH4G3FU5.js";
+import {
+  BuildConfigSchema,
+  DEFAULT_CONFIG,
+  DEFAULT_USER_PREFERENCES,
+  KNOWN_BUILD_CONFIG_ROOTS,
+  UserPreferencesSchema,
+  buildConfigCandidates,
+  isBuildConfigReadError,
+  selectedBuildConfigCandidate
+} from "./chunk-FKCG7K6H.js";
+import {
+  InvalidConfigContentError,
+  InvalidExplicitConfigError,
+  ProviderRegistry,
+  combineCacheFingerprints,
+  fingerprintEnvironment,
+  fingerprintFiles,
+  getConfiguredProviderRegistryPaths,
+  getProviderRegistryInputPaths
+} from "./chunk-QJ6OEH4K.js";
+import {
+  PROJECT_CONFIG_SCOPE_ERROR,
+  configDirWritable,
+  configExists,
+  ensureConfigDir,
+  findProjectRoot,
+  getConfigPaths,
+  projectConfigAliasesUserConfig
+} from "./chunk-35J4NE6S.js";
+import {
+  BUILD_CONFIG_ALLOW_DEFAULT_FALLBACK,
+  emitWarning,
+  readEnv
+} from "./chunk-7VRJHTGZ.js";
+
+// src/core/config/config-manager.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2, unlinkSync } from "fs";
+import { z } from "zod";
+
+// src/core/config/config-jsonc-edits.ts
+import { existsSync, readFileSync } from "fs";
+import { dirname } from "path";
+import { applyEdits, modify } from "jsonc-parser";
+import lockfile from "proper-lockfile";
+var LOCK_OPTIONS = { stale: 1e4, realpath: false };
+var LOCK_RETRIES = 50;
+var LOCK_RETRY_MS = 50;
+function lockConfigFileSync(filePath) {
+  for (let attempt = 0; ; attempt += 1) {
+    try {
+      return lockfile.lockSync(filePath, LOCK_OPTIONS);
+    } catch (error) {
+      if (error.code !== "ELOCKED" || attempt >= LOCK_RETRIES) {
+        throw error;
+      }
+      Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, LOCK_RETRY_MS);
+    }
+  }
+}
+function writeJsoncEdits(filePath, edits, baseDir) {
+  let release;
+  try {
+    release = lockConfigFileSync(filePath);
+    return editJsoncFile(filePath, edits, baseDir);
+  } catch (error) {
+    return { success: false, error: error instanceof Error ? error.message : "Unknown error" };
+  } finally {
+    release?.();
+  }
+}
+async function editOrCreateJsoncConfig(filePath, edits, baseDir, create) {
+  let release;
+  try {
+    if (!existsSync(dirname(filePath))) return await create();
+    release = await lockfile.lock(filePath, {
+      ...LOCK_OPTIONS,
+      retries: { retries: LOCK_RETRIES, minTimeout: LOCK_RETRY_MS, maxTimeout: LOCK_RETRY_MS }
+    });
+    return existsSync(filePath) ? editJsoncFile(filePath, edits, baseDir) : await create();
+  } catch (error) {
+    return { success: false, error: error instanceof Error ? error.message : "Unknown error" };
+  } finally {
+    await release?.().catch(() => void 0);
+  }
+}
+function editJsoncFile(filePath, edits, baseDir) {
+  try {
+    let updated = readFileSync(filePath, "utf8");
+    for (const edit of edits) {
+      updated = applyEdits(
+        updated,
+        modify(updated, edit.path, edit.value, {
+          formattingOptions: {
+            insertSpaces: true,
+            tabSize: 2
+          }
+        })
+      );
+    }
+    const result = atomicWrite(filePath, updated.endsWith("\n") ? updated : `${updated}
+`, {
+      baseDir
+    });
+    return result.success ? { success: true } : { success: false, error: result.error?.message };
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : "Unknown error"
+    };
+  }
+}
+
+// src/core/config/user-preferences-state.ts
+var USER_PREFERENCE_ROOT_KEYS = [
+  "version",
+  "userId",
+  "modelRouting",
+  "preferences",
+  "globalDefaults",
+  "migrations",
+  "firstTimeSetup"
+];
+function clone(value) {
+  return structuredClone(value);
+}
+function isPlainObject(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function mergePreferenceValues(existing, incoming) {
+  if (!isPlainObject(existing) || !isPlainObject(incoming)) return clone(incoming);
+  const merged = clone(existing);
+  for (const [key, value] of Object.entries(incoming)) {
+    merged[key] = mergePreferenceValues(merged[key], value);
+  }
+  return merged;
+}
+function topLevelSetupInitialized(value) {
+  return isPlainObject(value) && isFirstTimeDefaultsInitialized({ firstTimeSetup: value });
+}
+function preferencesFromUserState(state) {
+  const defaults = clone(DEFAULT_USER_PREFERENCES);
+  const stored = {};
+  for (const key of USER_PREFERENCE_ROOT_KEYS) {
+    if (key in state) stored[key] = state[key];
+  }
+  const candidate = mergePreferenceValues(defaults, stored);
+  UserPreferencesSchema.parse(candidate);
+  return candidate;
+}
+function replacePreferencesInUserState(state, preferences) {
+  const source = preferences;
+  for (const key of USER_PREFERENCE_ROOT_KEYS) {
+    if (key in source) {
+      state[key] = clone(source[key]);
+    } else {
+      delete state[key];
+    }
+  }
+}
+function recoverValidPreferenceRoots(state) {
+  const recovered = clone(state);
+  for (const key of USER_PREFERENCE_ROOT_KEYS) delete recovered[key];
+  let candidate = clone(DEFAULT_USER_PREFERENCES);
+  for (const key of USER_PREFERENCE_ROOT_KEYS) {
+    if (!(key in state)) continue;
+    const trial = { ...candidate, [key]: clone(state[key]) };
+    if (UserPreferencesSchema.safeParse(trial).success) {
+      candidate = trial;
+      recovered[key] = clone(state[key]);
+    }
+  }
+  return recovered;
+}
+function preferenceMutationOptions(filePath) {
+  return {
+    ...filePath ? { filePath } : {},
+    validateExisting: (state) => {
+      preferencesFromUserState(state);
+    },
+    recoverInvalidExisting: recoverValidPreferenceRoots
+  };
+}
+function readUserPreferencesState(filePath) {
+  const result = readUserState(filePath ? { filePath } : {});
+  return result.status === "valid" ? preferencesFromUserState(result.data) : null;
+}
+function snapshotUserPreferencesState(filePath) {
+  const result = readUserState(filePath ? { filePath } : {});
+  if (result.status !== "valid") return { status: result.status };
+  try {
+    return { status: "valid", preferences: preferencesFromUserState(result.data) };
+  } catch {
+    return { status: "corrupt" };
+  }
+}
+function restoreUserPreferencesState(snapshot, filePath) {
+  if (snapshot.status === "valid") {
+    return mutateUserState((state) => {
+      const replacement = clone(snapshot.preferences);
+      UserPreferencesSchema.parse(replacement);
+      replacePreferencesInUserState(state, replacement);
+      return replacement;
+    }, preferenceMutationOptions(filePath));
+  }
+  return mutateUserState(
+    (state) => {
+      for (const key of USER_PREFERENCE_ROOT_KEYS) delete state[key];
+      return null;
+    },
+    {
+      ...filePath ? { filePath } : {},
+      deleteIfEmpty: true
+    }
+  );
+}
+function resetFirstRunPreferencesState(filePath) {
+  return mutateUserPreferencesState((preferences) => {
+    delete preferences.firstTimeSetup;
+    preferences.preferences.cursor.firstTimeSetup = { completed: false };
+    delete preferences.globalDefaults.defaultProvider;
+    return void 0;
+  }, filePath);
+}
+function mutateUserPreferencesState(mutator, filePath) {
+  return mutateUserState((state) => {
+    const preferences = preferencesFromUserState(state);
+    const value = mutator(preferences);
+    UserPreferencesSchema.parse(preferences);
+    replacePreferencesInUserState(state, preferences);
+    return { preferences, value };
+  }, preferenceMutationOptions(filePath));
+}
+function writeUserPreferencesState(preferences, filePath) {
+  return mutateUserState((state) => {
+    const existing = preferencesFromUserState(state);
+    const merged = mergePreferenceValues(existing, preferences);
+    UserPreferencesSchema.parse(merged);
+    replacePreferencesInUserState(state, merged);
+    return merged;
+  }, preferenceMutationOptions(filePath));
+}
+function replaceUserPreferencesState(preferences, filePath) {
+  return mutateUserState((state) => {
+    UserPreferencesSchema.parse(preferences);
+    const replacement = clone(preferences);
+    const existing = preferencesFromUserState(state);
+    const replacementTopLevelInitialized = topLevelSetupInitialized(replacement.firstTimeSetup);
+    const replacementInitialized = isFirstTimeDefaultsInitialized(replacement);
+    if (topLevelSetupInitialized(existing.firstTimeSetup) && !replacementTopLevelInitialized) {
+      replacement.firstTimeSetup = clone(existing.firstTimeSetup);
+    }
+    if (isFirstTimeDefaultsInitialized(existing) && !replacementInitialized) {
+      replacement.preferences.cursor.firstTimeSetup = clone(
+        existing.preferences.cursor.firstTimeSetup
+      );
+    }
+    replacePreferencesInUserState(state, replacement);
+    return replacement;
+  }, preferenceMutationOptions(filePath));
+}
+
+// src/core/config/config-manager.ts
+function hasExplicitConfigSource(sources) {
+  return sources.some((source) => source.exists && source.type !== "default");
+}
+function allowInvalidConfigFallback() {
+  try {
+    return readEnv(BUILD_CONFIG_ALLOW_DEFAULT_FALLBACK).value === true;
+  } catch (error) {
+    throw new InvalidExplicitConfigError(
+      `Invalid BUILD_CONFIG_ALLOW_DEFAULT_FALLBACK value: ${error instanceof Error ? error.message : String(error)}`,
+      error
+    );
+  }
+}
+function cloneConfigValue(value) {
+  return structuredClone(value);
+}
+function cloneMergedConfigResult(config) {
+  return cloneConfigValue(config);
+}
+function snapshotFile(filePath) {
+  return existsSync2(filePath) ? { status: "present", content: readFileSync2(filePath, "utf8") } : { status: "missing" };
+}
+function restoreFileSnapshot(filePath, snapshot, baseDir) {
+  if (snapshot.status === "present") {
+    const result = atomicWrite(filePath, snapshot.content, { baseDir });
+    if (!result.success) throw result.error ?? new Error(`Could not restore ${filePath}`);
+    return;
+  }
+  try {
+    unlinkSync(filePath);
+  } catch (error) {
+    if (error.code !== "ENOENT") throw error;
+  }
+}
+function isPlaceholderModelDefault(registryDefault) {
+  const unqualified = registryDefault.trim().toLowerCase().split("/").pop() ?? "";
+  return unqualified === "auto" || unqualified === "default";
+}
+var ConfigManager = class {
+  cache = /* @__PURE__ */ new Map();
+  cacheHits = 0;
+  cacheMisses = 0;
+  options;
+  updateCursorModelQueue = Promise.resolve();
+  constructor(options = {}) {
+    this.options = {
+      enableCache: options.enableCache ?? true,
+      cacheTTL: options.cacheTTL ?? 5 * 60 * 1e3,
+      // 5 minutes
+      autoFix: options.autoFix ?? false,
+      cwd: options.cwd ?? process.cwd()
+    };
+  }
+  get paths() {
+    return getConfigPaths(this.options.cwd);
+  }
+  buildLoadCacheKey(cliFlags) {
+    const paths = this.paths;
+    const filePaths = [
+      ...buildConfigCandidates(paths.projectConfigFile),
+      ...buildConfigCandidates(paths.userConfigFile),
+      paths.userPreferencesFile,
+      getActiveProfilePath(),
+      ...getProviderRegistryInputPaths(this.options.cwd)
+    ].filter((value) => value !== void 0);
+    return JSON.stringify({
+      cliFlags,
+      cwd: this.options.cwd,
+      fingerprint: combineCacheFingerprints(
+        fingerprintEnvironment(process.env, () => true),
+        fingerprintFiles(filePaths)
+      )
+    });
+  }
+  /**
+   * Load configuration from all sources with precedence
+   *
+   * @param cliFlags - CLI flag overrides
+   * @param forceReload - Skip cache and reload
+   * @returns Resolved configuration with metadata
+   */
+  async loadConfig(cliFlags = {}, forceReload = false) {
+    const startTime = Date.now();
+    const cacheKey = this.buildLoadCacheKey(cliFlags);
+    try {
+      if (!forceReload && this.options.enableCache) {
+        const cached = this.getFromCache(cacheKey);
+        if (cached) {
+          return cached;
+        }
+      }
+      const allowDefaultFallback = allowInvalidConfigFallback();
+      const explicitProviderRegistryPaths = getConfiguredProviderRegistryPaths(
+        this.options.cwd
+      ).filter((path) => existsSync2(path));
+      if (explicitProviderRegistryPaths.length > 0) {
+        try {
+          ProviderRegistry.load(void 0, this.options.cwd);
+        } catch (error) {
+          if (!allowDefaultFallback) {
+            throw new InvalidExplicitConfigError(
+              `Invalid explicit provider registry: ${error instanceof Error ? error.message : String(error)}`,
+              error
+            );
+          }
+        }
+      }
+      const sources = await loadAllConfigSources(this.options.cwd, cliFlags);
+      const mergeResult = mergeConfigSources(sources);
+      const validationResult = validateBuildConfig(mergeResult.mergedConfig, {
+        includeWarnings: true,
+        includeSuggestions: true,
+        cwd: this.options.cwd
+      });
+      let finalConfig = mergeResult.mergedConfig;
+      if (this.options.autoFix && !validationResult.isValid) {
+        const autoFixResult = autoFixConfig(mergeResult.mergedConfig);
+        if (autoFixResult.changes.length > 0) {
+          finalConfig = autoFixResult.fixedConfig;
+          emitWarning(
+            "CFG-002",
+            {
+              taskId: "config-manager",
+              subsystem: "config",
+              executionPhase: "setup"
+            },
+            {
+              severity: "INFO" /* INFO */,
+              metadata: {
+                changes: autoFixResult.changes,
+                operation: "loadConfig"
+              }
+            }
+          );
+        }
+      }
+      const finalValidationResult = finalConfig === mergeResult.mergedConfig ? validationResult : validateBuildConfig(finalConfig, {
+        includeWarnings: true,
+        includeSuggestions: true,
+        cwd: this.options.cwd
+      });
+      if (!finalValidationResult.isValid) {
+        const explicitConfigInvalid = hasExplicitConfigSource(sources) || getConfiguredProviderRegistryPaths(this.options.cwd).some((path) => existsSync2(path));
+        emitWarning(
+          "CFG-003",
+          {
+            taskId: "config-manager",
+            subsystem: "config",
+            executionPhase: "setup"
+          },
+          {
+            severity: "ERROR" /* ERROR */,
+            metadata: {
+              operation: "loadConfig",
+              errors: finalValidationResult.errors,
+              sourceTypes: sources.filter((source) => source.exists).map((source) => source.type),
+              fallback: explicitConfigInvalid && !allowDefaultFallback ? "blocked-invalid-explicit-config" : "default-config"
+            }
+          }
+        );
+        if (explicitConfigInvalid && !allowDefaultFallback) {
+          throw new InvalidConfigContentError(
+            `Invalid explicit Build configuration: ${finalValidationResult.errors.map((err) => err.message).join("; ")}`
+          );
+        }
+        finalConfig = cloneConfigValue(DEFAULT_CONFIG);
+      }
+      const isFirstTimeUser = await this.detectFirstTimeUser();
+      const resolvedConfig = {
+        config: finalConfig,
+        sources,
+        isFirstTimeUser,
+        loadTime: Date.now() - startTime
+      };
+      this.validateProviderDefaultsConsistency(resolvedConfig.config);
+      if (this.options.enableCache) {
+        this.setCache(cacheKey, resolvedConfig);
+      }
+      return cloneMergedConfigResult(resolvedConfig);
+    } catch (error) {
+      if (error instanceof InvalidExplicitConfigError) {
+        throw error;
+      }
+      if (isBuildConfigReadError(error)) {
+        throw error;
+      }
+      throw error;
+    }
+  }
+  /** Registry-first execution defaults with source attribution. */
+  resolveExecutionConfig(cli = {}) {
+    return resolveConfig(cli, this.options.cwd, { strictSynthesisModel: false });
+  }
+  /**
+   * Write user preferences atomically
+   *
+   * @param preferences - User preferences to write
+   * @returns Success status
+   */
+  async writeUserPreferences(preferences) {
+    try {
+      const result = writeUserPreferencesState(preferences, this.paths.userPreferencesFile);
+      this.emitUserStateWarnings(result.warnings);
+      this.invalidateCache();
+      return { success: true };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Unknown error"
+      };
+    }
+  }
+  /**
+   * Load user preferences
+   *
+   * @returns User preferences or null
+   */
+  async loadUserPreferences() {
+    try {
+      const preferences = readUserPreferencesState(this.paths.userPreferencesFile);
+      return preferences ? cloneConfigValue(preferences) : null;
+    } catch {
+      return null;
+    }
+  }
+  /** Write project config atomically, preserving user-scope ownership. */
+  async writeProjectConfig(config) {
+    if (projectConfigAliasesUserConfig(this.options.cwd)) {
+      return PROJECT_CONFIG_SCOPE_ERROR;
+    }
+    try {
+      await this.excludeProjectConfigBackups();
+      if (!ensureConfigDir(this.paths.projectConfigDir)) {
+        return {
+          success: false,
+          error: "Cannot create project config directory"
+        };
+      }
+      const configContent = this.generateConfigFileContent(config);
+      const result = atomicWrite(this.paths.projectConfigFile, configContent, {
+        baseDir: findProjectRoot(this.options.cwd) ?? this.options.cwd
+      });
+      if (!result.success) {
+        return { success: false, error: result.error?.message };
+      }
+      this.invalidateCache();
+      return { success: true };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Unknown error"
+      };
+    }
+  }
+  /** Apply only repaired JSONC paths in the existing project candidate, retaining comments. */
+  async applyProjectConfigFixes(edits) {
+    if (edits.length === 0) return { success: true };
+    if (projectConfigAliasesUserConfig(this.options.cwd)) {
+      return PROJECT_CONFIG_SCOPE_ERROR;
+    }
+    const projectConfigFile = selectedBuildConfigCandidate(this.paths.projectConfigFile);
+    const projectConfig = edits.reduce(
+      (config, edit) => this.setNestedValue(config, edit.path, edit.value),
+      {}
+    );
+    return this.applyJsoncEdits(
+      projectConfigFile,
+      edits,
+      () => this.writeProjectConfig(projectConfig)
+    );
+  }
+  /**
+   * Update user configuration atomically (~/.config/build/build.config.jsonc)
+   *
+   * @param config - User configuration to write
+   * @returns Success status
+   */
+  async writeUserConfig(config) {
+    try {
+      if (!ensureConfigDir(this.paths.userConfigDir)) {
+        return {
+          success: false,
+          error: "Cannot create user config directory"
+        };
+      }
+      const configContent = this.generateConfigFileContent(config);
+      const result = atomicWrite(this.paths.userConfigFile, configContent, {
+        baseDir: this.options.cwd
+      });
+      if (!result.success) {
+        return { success: false, error: result.error?.message };
+      }
+      this.invalidateCache();
+      return { success: true };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Unknown error"
+      };
+    }
+  }
+  /**
+   * Load project configuration
+   *
+   * @returns Project configuration or null
+   */
+  async loadProjectConfig() {
+    return loadProjectConfig(this.paths.projectConfigFile, this.options.cwd);
+  }
+  /**
+   * Update cursor model preference
+   *
+   * @param model - New cursor model
+   * @param context - Change context
+   * @returns Success status
+   */
+  async updateCursorModel(model, context) {
+    return this.runSerializedCursorModelUpdate(async () => {
+      try {
+        const result = mutateUserPreferencesState((preferences) => {
+          const cursor = preferences.preferences.cursor;
+          const previousModel = cursor.usageHistory.lastUsed;
+          cursor.userChosenDefault = model;
+          cursor.usageHistory.lastUsed = model;
+          cursor.usageHistory.usageCount += 1;
+          cursor.usageHistory.modelChanges ??= [];
+          cursor.usageHistory.modelChanges.push({
+            from: previousModel ?? "",
+            to: model,
+            timestamp: context.timestamp || (/* @__PURE__ */ new Date()).toISOString(),
+            context: context.type
+          });
+        }, this.paths.userPreferencesFile);
+        this.emitUserStateWarnings(result.warnings);
+        this.invalidateCache();
+        return { success: true };
+      } catch (error) {
+        return {
+          success: false,
+          error: error instanceof Error ? error.message : "Unknown error"
+        };
+      }
+    });
+  }
+  /**
+   * Detect if this is a first-time user
+   *
+   * @returns True if first-time user
+   */
+  async detectFirstTimeUser() {
+    try {
+      const userPrefs = await this.loadUserPreferences();
+      return !isFirstTimeDefaultsInitialized(userPrefs);
+    } catch {
+      return true;
+    }
+  }
+  /**
+   * Get configuration diagnostics
+   *
+   * @returns Diagnostic information
+   */
+  async getDiagnostics() {
+    const paths = {
+      projectConfigFile: {
+        exists: buildConfigCandidates(this.paths.projectConfigFile).some(configExists)
+      },
+      userConfigFile: {
+        exists: buildConfigCandidates(this.paths.userConfigFile).some(configExists)
+      },
+      userPreferencesFile: {
+        exists: configExists(this.paths.userPreferencesFile)
+      },
+      userConfigDir: {
+        exists: configExists(this.paths.userConfigDir),
+        writable: configDirWritable(this.paths.userConfigDir, { createIfMissing: false })
+      },
+      projectConfigDir: {
+        exists: configExists(this.paths.projectConfigDir),
+        writable: configDirWritable(this.paths.projectConfigDir, { createIfMissing: false })
+      }
+    };
+    const cache = {
+      enabled: this.options.enableCache,
+      size: this.cache.size,
+      entries: Array.from(this.cache.entries()).map(([key, entry]) => ({
+        key: `${key.substring(0, 50)}...`,
+        age: Date.now() - entry.timestamp
+      }))
+    };
+    const config = await this.loadConfig();
+    const validationResult = validateBuildConfig(config.config, { cwd: this.options.cwd });
+    const validation = {
+      isValid: validationResult.isValid,
+      errors: validationResult.errors.map((e) => e.message),
+      warnings: validationResult.warnings.map((w) => w.message),
+      autoFixed: validationResult.autoFixed
+    };
+    const performance = {
+      avgLoadTime: config.loadTime,
+      cacheHitRate: this.calculateCacheHitRate()
+    };
+    return { paths, cache, validation, performance };
+  }
+  /**
+   * Clear configuration cache
+   */
+  clearCache() {
+    this.cache.clear();
+    this.cacheHits = 0;
+    this.cacheMisses = 0;
+  }
+  /**
+   * Invalidate cache for current working directory
+   *
+   * CRITICAL FIX: Atomic cache invalidation to prevent race conditions.
+   * Collect all keys first, then delete them atomically to ensure
+   * consistent cache state during concurrent access.
+   */
+  invalidateCache() {
+    const keysToDelete = [];
+    for (const [key] of this.cache) {
+      if (key.includes(this.options.cwd)) {
+        keysToDelete.push(key);
+      }
+    }
+    for (const key of keysToDelete) {
+      this.cache.delete(key);
+    }
+  }
+  /**
+   * Get configuration from cache
+   *
+   * @param key - Cache key
+   * @returns Cached configuration or null
+   */
+  getFromCache(key) {
+    const entry = this.cache.get(key);
+    if (!entry) {
+      this.cacheMisses += 1;
+      return null;
+    }
+    if (Date.now() - entry.timestamp > this.options.cacheTTL) {
+      this.cache.delete(key);
+      this.cacheMisses += 1;
+      return null;
+    }
+    this.cacheHits += 1;
+    return cloneMergedConfigResult(entry.config);
+  }
+  /**
+   * Set configuration in cache
+   *
+   * @param key - Cache key
+   * @param config - Configuration to cache
+   */
+  setCache(key, config) {
+    this.cache.set(key, {
+      config: cloneMergedConfigResult(config),
+      timestamp: Date.now(),
+      sources: config.sources.map((s) => s.type)
+    });
+  }
+  async runSerializedCursorModelUpdate(operation) {
+    let release = () => {
+    };
+    const previous = this.updateCursorModelQueue;
+    this.updateCursorModelQueue = new Promise((resolve) => {
+      release = resolve;
+    });
+    await previous;
+    try {
+      return await operation();
+    } finally {
+      release?.();
+    }
+  }
+  /**
+   * Calculate cache hit rate
+   *
+   * @returns Cache hit rate as percentage
+   */
+  calculateCacheHitRate() {
+    const totalLookups = this.cacheHits + this.cacheMisses;
+    if (totalLookups === 0) {
+      return 0;
+    }
+    return Math.round(this.cacheHits / totalLookups * 1e3) / 10;
+  }
+  emitUserStateWarnings(warnings) {
+    for (const warning of warnings) {
+      emitWarning(
+        "CFG-001",
+        { taskId: "config-manager", subsystem: "config", executionPhase: "setup" },
+        {
+          severity: "WARN" /* WARN */,
+          metadata: { operation: "writeUserPreferences", ...warning }
+        }
+      );
+    }
+  }
+  /**
+   * Detect and warn about provider default drift (all providers with model defaults).
+   */
+  validateProviderDefaultsConsistency(config) {
+    try {
+      const registry = ProviderRegistry.load(void 0, this.options.cwd);
+      const providersWithModels = Object.values(registry.providers).filter(
+        (p) => p.models?.default
+      );
+      for (const providerConfig of providersWithModels) {
+        const providerId = providerConfig.id;
+        const registryDefault = providerConfig.models.default;
+        const providerEntry = config.providers?.[providerId];
+        const configured = providerEntry && typeof providerEntry === "object" && "model" in providerEntry && typeof providerEntry.model === "string" ? providerEntry.model : void 0;
+        if (configured && configured !== registryDefault && !isPlaceholderModelDefault(registryDefault)) {
+          emitWarning(
+            "CFG-007",
+            {
+              taskId: "config-manager",
+              subsystem: "config",
+              executionPhase: "setup"
+            },
+            {
+              severity: "WARN" /* WARN */,
+              metadata: {
+                provider: providerId,
+                configuredDefault: configured,
+                registryDefault,
+                recommendation: "Remove the model override or align it with providers.yaml"
+              }
+            }
+          );
+        }
+      }
+    } catch (error) {
+      emitWarning(
+        "CFG-002",
+        {
+          taskId: "config-manager",
+          subsystem: "config",
+          executionPhase: "setup"
+        },
+        {
+          severity: "INFO" /* INFO */,
+          metadata: {
+            error: error instanceof Error ? error.message : String(error),
+            recommendation: "Ensure provider registry is valid to compare defaults"
+          }
+        }
+      );
+    }
+  }
+  /**
+   * Set a configuration value using dot-notation path
+   *
+   * @param path - Dot-notation path (e.g., 'defaults.provider', 'automation.flywheel.merge.biomeRepair')
+   * @param value - Value to set
+   * @param scope - Configuration scope ('user' or 'project')
+   * @returns Success status with previous value
+   */
+  async setConfigValue(path, value, scope = "project") {
+    try {
+      const pathSegments = path.split(".").filter(Boolean);
+      if (pathSegments.length === 0) {
+        return { success: false, error: "Invalid configuration path" };
+      }
+      if (!this.isValidConfigPath(pathSegments)) {
+        return {
+          success: false,
+          error: `Unknown configuration path: ${path}. Use 'build config show' to see valid paths.`
+        };
+      }
+      const config = await this.loadScopedConfig(scope);
+      const previousValue = this.getNestedValue(config, pathSegments);
+      const parsedValue = this.parseConfigValue(value);
+      const updatedConfig = this.setNestedValue(config, pathSegments, parsedValue);
+      const validationResult = BuildConfigSchema.safeParse(updatedConfig);
+      if (!validationResult.success) {
+        return {
+          success: false,
+          error: `Invalid configuration: ${validationResult.error.issues.map((issue) => issue.message).join(", ")}`
+        };
+      }
+      if (!this.hasNestedPath(validationResult.data, pathSegments)) {
+        return {
+          success: false,
+          error: `Unknown configuration path: ${path}. Use 'build config show' to see valid paths.`
+        };
+      }
+      const keyError = registryErrorAtPath(validationResult.data, pathSegments, this.options.cwd);
+      if (keyError) {
+        return { success: false, error: keyError };
+      }
+      const writeResult = await this.writeConfigValuePreservingJsonc(
+        scope,
+        pathSegments,
+        parsedValue,
+        updatedConfig
+        // unparsed: never persist schema defaults
+      );
+      if (!writeResult.success) {
+        return writeResult;
+      }
+      return { success: true, previousValue };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Unknown error"
+      };
+    }
+  }
+  /**
+   * Get a configuration value using dot-notation path
+   *
+   * @param path - Dot-notation path
+   * @param scope - Configuration scope ('user' or 'project')
+   * @returns The value at the path or undefined
+   */
+  async getConfigValue(path, scope = "project") {
+    const config = await this.loadScopedConfig(scope);
+    return this.getNestedValue(config, path.split(".").filter(Boolean));
+  }
+  /**
+   * Read one raw config layer. The user layer is read from its own file rather
+   * than through loadConfig(), so a value that makes the merged tree invalid can
+   * still be read and replaced in place.
+   */
+  async loadScopedConfig(scope) {
+    return scope === "project" ? await this.loadProjectConfig() ?? {} : await loadUserConfig(this.paths.userConfigFile, this.options.cwd) ?? {};
+  }
+  /**
+   * Validate a configuration path against allowed paths
+   */
+  isValidConfigPath(pathSegments) {
+    const rootNamespace = pathSegments[0];
+    if (!rootNamespace || !KNOWN_BUILD_CONFIG_ROOTS.includes(rootNamespace)) {
+      return false;
+    }
+    return true;
+  }
+  /**
+   * Get nested value from object using path segments
+   */
+  getNestedValue(obj, path) {
+    let current = obj;
+    for (const segment of path) {
+      if (current == null || typeof current !== "object") {
+        return void 0;
+      }
+      current = current[segment];
+    }
+    return current;
+  }
+  hasNestedPath(obj, path) {
+    let current = obj;
+    for (const segment of path) {
+      if (current == null || typeof current !== "object" || !Object.hasOwn(current, segment)) {
+        return false;
+      }
+      current = current[segment];
+    }
+    return true;
+  }
+  /**
+   * Set nested value in object using path segments (immutable)
+   */
+  setNestedValue(obj, path, value) {
+    const result = structuredClone(obj);
+    let current = result;
+    for (let i = 0; i < path.length - 1; i++) {
+      const segment = path[i];
+      if (!segment) {
+        continue;
+      }
+      if (!(segment in current) || typeof current[segment] !== "object" || current[segment] === null) {
+        current[segment] = {};
+      }
+      current = current[segment];
+    }
+    const lastSegment = path[path.length - 1];
+    if (lastSegment) {
+      current[lastSegment] = value;
+    }
+    return result;
+  }
+  /**
+   * Parse config value from string to appropriate type
+   */
+  parseConfigValue(value) {
+    if (typeof value !== "string") {
+      return value;
+    }
+    const trimmed = value.trim();
+    if (trimmed.startsWith("[") && trimmed.endsWith("]") || trimmed.startsWith("{") && trimmed.endsWith("}")) {
+      try {
+        return JSON.parse(trimmed);
+      } catch {
+        return value;
+      }
+    }
+    if (value.toLowerCase() === "true") return true;
+    if (value.toLowerCase() === "false") return false;
+    const num = Number(value);
+    if (!Number.isNaN(num) && value.trim() !== "") {
+      return num;
+    }
+    if (value.toLowerCase() === "null") return null;
+    if (value.toLowerCase() === "undefined") return void 0;
+    return value;
+  }
+  /**
+   * Generate JSONC configuration file content
+   *
+   * @param config - Configuration object
+   * @returns JSONC file content
+   */
+  generateConfigFileContent(config) {
+    return `{
+  // Build configuration.
+  // JSONC is JSON with comments and trailing commas; use "build config set/get"
+  // to edit this safely, or hand-edit it with a JSONC-aware editor.
+${JSON.stringify(config, null, 2).split("\n").map((line, index) => index === 0 ? line.slice(1) : `  ${line}`).join("\n")}
+`;
+  }
+  async writeConfigValuePreservingJsonc(scope, pathSegments, value, validatedConfig) {
+    if (scope === "project" && projectConfigAliasesUserConfig(this.options.cwd)) {
+      return PROJECT_CONFIG_SCOPE_ERROR;
+    }
+    const filePath = selectedBuildConfigCandidate(
+      scope === "project" ? this.paths.projectConfigFile : this.paths.userConfigFile
+    );
+    return this.applyJsoncEdits(
+      filePath,
+      [{ path: pathSegments, value }],
+      () => scope === "project" ? this.writeProjectConfig(validatedConfig) : this.writeUserConfig(validatedConfig)
+    );
+  }
+  /** Edit a config file in place, or create it when absent; invalidates the cache once written. */
+  async applyJsoncEdits(filePath, edits, create) {
+    const projectRoot = findProjectRoot(this.options.cwd) ?? this.options.cwd;
+    const isUserFile = buildConfigCandidates(this.paths.userConfigFile).includes(filePath);
+    const baseDir = isUserFile ? this.options.cwd : projectRoot;
+    if (!isUserFile) await this.excludeProjectConfigBackups();
+    const result = await editOrCreateJsoncConfig(filePath, edits, baseDir, create);
+    if (result.success) {
+      this.invalidateCache();
+    }
+    return result;
+  }
+  async excludeProjectConfigBackups() {
+    const { ensureWorktreeGitExclude } = await import("./worktree-environment-WTVABAQW.js");
+    await ensureWorktreeGitExclude(findProjectRoot(this.options.cwd) ?? this.options.cwd, [
+      "/.build-project/config/*.backup.*"
+    ]);
+  }
+  /** Reset the selected scopes; refuse aliased project scope before either write. */
+  async resetToDefaults(level = "project") {
+    if (level !== "user" && projectConfigAliasesUserConfig(this.options.cwd)) {
+      return PROJECT_CONFIG_SCOPE_ERROR;
+    }
+    try {
+      if (level === "user" || level === "all") {
+        const userConfigSnapshot = snapshotFile(this.paths.userConfigFile);
+        const userResult = await this.writeUserConfig({});
+        if (!userResult.success) return userResult;
+        if (level === "all") {
+          const projectResult = await this.writeProjectConfig({});
+          if (!projectResult.success) {
+            const rollbackErrors = [];
+            try {
+              restoreFileSnapshot(this.paths.userConfigFile, userConfigSnapshot, this.options.cwd);
+            } catch (error) {
+              rollbackErrors.push(
+                `user config rollback failed: ${error instanceof Error ? error.message : String(error)}`
+              );
+            }
+            return rollbackErrors.length === 0 ? projectResult : {
+              success: false,
+              error: `${projectResult.error ?? "Project config write failed"}; ${rollbackErrors.join("; ")}`
+            };
+          }
+        }
+      } else if (level === "project") {
+        const result = await this.writeProjectConfig({});
+        if (!result.success) return result;
+      }
+      this.clearCache();
+      return { success: true };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Unknown error"
+      };
+    }
+  }
+  /**
+   * Export configuration for backup or sharing
+   *
+   * @param includeUserPreferences - Whether to include user preferences
+   * @returns Export data
+   */
+  async exportConfig(includeUserPreferences = false) {
+    const config = await this.loadConfig();
+    const result = {
+      config: redactSensitiveConfig(config.config),
+      metadata: {
+        exportedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        version: "1.0",
+        cwd: this.options.cwd
+      }
+    };
+    if (includeUserPreferences) {
+      const prefs = await this.loadUserPreferences();
+      if (prefs) {
+        result.preferences = redactSensitiveConfig(prefs);
+      }
+    }
+    return result;
+  }
+  /**
+   * Import configuration from exported data
+   *
+   * @param exportData - Exported configuration data
+   * @param importPreferences - Whether to import user preferences
+   * @returns Success status
+   */
+  async importConfig(exportData, importPreferences = false) {
+    try {
+      if (!exportData || typeof exportData !== "object" || !("config" in exportData) || !("metadata" in exportData)) {
+        return { success: false, error: "Invalid export data format" };
+      }
+      const metadataResult = z.object({
+        exportedAt: z.string().min(1),
+        version: z.string().min(1),
+        cwd: z.string()
+      }).strict().safeParse(exportData.metadata);
+      if (!metadataResult.success) {
+        return {
+          success: false,
+          error: `Invalid export data format: ${metadataResult.error.issues.map((issue) => `${issue.path.join(".") || "<root>"}: ${issue.message}`).join("; ")}`
+        };
+      }
+      const unknownConfigRoots = exportData.config && typeof exportData.config === "object" && !Array.isArray(exportData.config) ? Object.keys(exportData.config).filter((key) => !KNOWN_BUILD_CONFIG_ROOTS.includes(key)) : [];
+      if (unknownConfigRoots.length > 0) {
+        return {
+          success: false,
+          error: `Invalid imported configuration: Unknown top-level configuration key(s): ${unknownConfigRoots.join(", ")}`
+        };
+      }
+      const configResult = BuildConfigSchema.safeParse(exportData.config);
+      if (!configResult.success) {
+        return {
+          success: false,
+          error: `Invalid imported configuration: ${configResult.error.issues.map((issue) => `${issue.path.join(".") || "<root>"}: ${issue.message}`).join("; ")}`
+        };
+      }
+      let validatedPreferences;
+      let previousPreferences;
+      if (importPreferences && exportData.preferences !== void 0) {
+        const preferencesResult = UserPreferencesSchema.safeParse(exportData.preferences);
+        if (!preferencesResult.success) {
+          return {
+            success: false,
+            error: `Invalid imported preferences: ${preferencesResult.error.issues.map((issue) => `${issue.path.join(".") || "<root>"}: ${issue.message}`).join("; ")}`
+          };
+        }
+        validatedPreferences = preferencesResult.data;
+        previousPreferences = snapshotUserPreferencesState(this.paths.userPreferencesFile);
+      }
+      if (validatedPreferences) {
+        try {
+          const prefResult = replaceUserPreferencesState(
+            validatedPreferences,
+            this.paths.userPreferencesFile
+          );
+          this.emitUserStateWarnings(prefResult.warnings);
+        } catch (error) {
+          return {
+            success: false,
+            error: error instanceof Error ? error.message : "Unknown error"
+          };
+        }
+      }
+      const result = await this.writeProjectConfig(configResult.data);
+      if (!result.success) {
+        if (previousPreferences) {
+          try {
+            restoreUserPreferencesState(previousPreferences, this.paths.userPreferencesFile);
+          } catch (rollbackError) {
+            return {
+              success: false,
+              error: `${result.error ?? "Project config write failed"}; preference rollback also failed: ${rollbackError instanceof Error ? rollbackError.message : String(rollbackError)}`
+            };
+          }
+        }
+        return result;
+      }
+      this.clearCache();
+      return { success: true };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Unknown error"
+      };
+    }
+  }
+};
+
+export {
+  writeJsoncEdits,
+  preferencesFromUserState,
+  snapshotUserPreferencesState,
+  restoreUserPreferencesState,
+  resetFirstRunPreferencesState,
+  mutateUserPreferencesState,
+  writeUserPreferencesState,
+  replaceUserPreferencesState,
+  isPlaceholderModelDefault,
+  ConfigManager
+};
+//# sourceMappingURL=chunk-W4BAIQ6L.js.map