@poetic-ai/poetic 1.42.0

package/dist/chunk-H66DXFS5.js

@@ -0,0 +1,1374 @@
+import {
+  redactSensitiveConfig
+} from "./chunk-3M57DADF.js";
+import {
+  autoFixConfig,
+  isFirstTimeDefaultsInitialized,
+  validatePoeticConfig
+} from "./chunk-CUSRN6RJ.js";
+import {
+  resolveConfig
+} from "./chunk-XPU2XADL.js";
+import {
+  getActiveProfilePath,
+  loadAllConfigSources,
+  loadProjectConfig,
+  mutateUserState,
+  normalizeLegacyIntoCanonical,
+  normalizeMergedConfigTree,
+  readUserState
+} from "./chunk-SZ7DL357.js";
+import {
+  atomicWrite
+} from "./chunk-J6P3FWWW.js";
+import {
+  DEFAULT_CONFIG,
+  DEFAULT_USER_PREFERENCES,
+  KNOWN_POETIC_CONFIG_ROOTS,
+  PoeticConfigSchema,
+  UserPreferencesSchema,
+  isPoeticConfigReadError,
+  poeticConfigCandidates
+} from "./chunk-G36W2T2S.js";
+import {
+  InvalidExplicitConfigError,
+  ProviderRegistry,
+  combineCacheFingerprints,
+  fingerprintEnvironment,
+  fingerprintFiles,
+  getConfiguredProviderRegistryPaths,
+  getProviderRegistryInputPaths
+} from "./chunk-AT4TNPWW.js";
+import {
+  configDirWritable,
+  configExists,
+  ensureConfigDir,
+  getConfigPaths
+} from "./chunk-L6OM4A22.js";
+import {
+  emitWarning
+} from "./chunk-EJGCZGUF.js";
+import {
+  POETIC_CONFIG_ALLOW_DEFAULT_FALLBACK,
+  readEnv
+} from "./chunk-5DLKYTQX.js";
+
+// src/core/config/config-manager.ts
+import { existsSync, readFileSync, unlinkSync } from "fs";
+import { applyEdits, modify } from "jsonc-parser";
+import { z } from "zod";
+
+// src/core/config/config-merger.ts
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) && (Object.getPrototypeOf(value) === Object.prototype || Object.getPrototypeOf(value) === null);
+}
+function isUnsafeMergeKey(key) {
+  return key === "__proto__" || key === "constructor" || key === "prototype";
+}
+function deepMerge(target, source, keyPath = "", conflicts = []) {
+  if (source === null || source === void 0) {
+    return target;
+  }
+  if (target === null || target === void 0) {
+    return source;
+  }
+  if (typeof target !== "object" || typeof source !== "object" || Array.isArray(target) !== Array.isArray(source)) {
+    return source;
+  }
+  const isArray = Array.isArray(target);
+  const result = isArray ? Object.create(Array.prototype) : /* @__PURE__ */ Object.create(null);
+  const allKeys = /* @__PURE__ */ new Set([...Object.keys(target), ...Object.keys(source)]);
+  for (const key of allKeys) {
+    if (isUnsafeMergeKey(key)) {
+      continue;
+    }
+    const currentKeyPath = keyPath ? `${keyPath}.${key}` : key;
+    const targetValue = target[key];
+    const sourceValue = source[key];
+    if (!(key in source)) {
+      result[key] = targetValue;
+      continue;
+    }
+    if (!(key in target)) {
+      result[key] = sourceValue;
+      continue;
+    }
+    if (isPlainObject(targetValue) && isPlainObject(sourceValue)) {
+      result[key] = deepMerge(targetValue, sourceValue, currentKeyPath, conflicts);
+    } else {
+      if (JSON.stringify(targetValue) !== JSON.stringify(sourceValue)) {
+        conflicts.push({
+          key: currentKeyPath,
+          source1: targetValue,
+          source2: sourceValue,
+          resolvedWith: "high-priority-wins"
+        });
+      }
+      result[key] = sourceValue;
+    }
+  }
+  return result;
+}
+function mergeProviderConfigs(target = {}, source = {}, conflicts = []) {
+  const result = {};
+  const handledProviders = /* @__PURE__ */ new Set();
+  const resultRecord = result;
+  const targetRecord = target;
+  const sourceRecord = source;
+  for (const provider of ["claude", "codex", "cursor", "copilot"]) {
+    handledProviders.add(provider);
+    const targetProvider = target[provider];
+    const sourceProvider = source[provider];
+    if (!sourceProvider) {
+      if (targetProvider) {
+        result[provider] = targetProvider;
+      }
+      continue;
+    }
+    if (!targetProvider) {
+      result[provider] = sourceProvider;
+      continue;
+    }
+    result[provider] = { ...targetProvider };
+    for (const [key, sourceValue] of Object.entries(sourceProvider)) {
+      if (sourceValue === void 0) {
+        continue;
+      }
+      const targetValue = targetProvider[key];
+      if (key === "preferences" && isPlainObject(sourceValue) && isPlainObject(targetValue)) {
+        const currentProvider = result[provider];
+        if (currentProvider && typeof currentProvider === "object" && currentProvider !== null && "preferences" in currentProvider) {
+          currentProvider.preferences = deepMerge(
+            targetValue,
+            sourceValue,
+            `providers.${provider}.preferences`,
+            conflicts
+          );
+        }
+      } else {
+        if (targetValue !== void 0 && JSON.stringify(targetValue) !== JSON.stringify(sourceValue)) {
+          conflicts.push({
+            key: `providers.${provider}.${key}`,
+            source1: targetValue,
+            source2: sourceValue,
+            resolvedWith: "high-priority-wins"
+          });
+        }
+        result[provider][key] = sourceValue;
+      }
+    }
+  }
+  for (const provider of ["gemini", "opencode"]) {
+    handledProviders.add(provider);
+    const targetProvider = target[provider];
+    const sourceProvider = source[provider];
+    if (!sourceProvider) {
+      if (targetProvider) result[provider] = targetProvider;
+      continue;
+    }
+    if (!targetProvider) {
+      result[provider] = sourceProvider;
+      continue;
+    }
+    if (isPlainObject(targetProvider) && isPlainObject(sourceProvider)) {
+      result[provider] = deepMerge(
+        targetProvider,
+        sourceProvider,
+        `providers.${provider}`,
+        conflicts
+      );
+    } else {
+      result[provider] = sourceProvider;
+    }
+  }
+  const dynamicProviders = /* @__PURE__ */ new Set([...Object.keys(target), ...Object.keys(source)]);
+  for (const provider of dynamicProviders) {
+    if (handledProviders.has(provider) || isUnsafeMergeKey(provider)) {
+      continue;
+    }
+    const targetProvider = targetRecord[provider];
+    const sourceProvider = sourceRecord[provider];
+    if (sourceProvider === void 0) {
+      if (targetProvider !== void 0) {
+        resultRecord[provider] = targetProvider;
+      }
+      continue;
+    }
+    if (targetProvider === void 0) {
+      resultRecord[provider] = sourceProvider;
+      continue;
+    }
+    if (isPlainObject(targetProvider) && isPlainObject(sourceProvider)) {
+      resultRecord[provider] = deepMerge(
+        targetProvider,
+        sourceProvider,
+        `providers.${provider}`,
+        conflicts
+      );
+    } else {
+      if (JSON.stringify(targetProvider) !== JSON.stringify(sourceProvider)) {
+        conflicts.push({
+          key: `providers.${provider}`,
+          source1: targetProvider,
+          source2: sourceProvider,
+          resolvedWith: "high-priority-wins"
+        });
+      }
+      resultRecord[provider] = sourceProvider;
+    }
+  }
+  return result;
+}
+function mergeQualityConfigs(target = {}, source = {}, conflicts = []) {
+  const resultRecord = {};
+  for (const [key, value] of Object.entries(target)) {
+    resultRecord[key] = value;
+  }
+  for (const [section, sourceValue] of Object.entries(source)) {
+    const targetValue = target[section];
+    if (targetValue === void 0) {
+      resultRecord[section] = sourceValue;
+      continue;
+    }
+    if (isPlainObject(sourceValue) && isPlainObject(targetValue)) {
+      resultRecord[section] = deepMerge(targetValue, sourceValue, `quality.${section}`, conflicts);
+    } else {
+      if (JSON.stringify(targetValue) !== JSON.stringify(sourceValue)) {
+        conflicts.push({
+          key: `quality.${section}`,
+          source1: targetValue,
+          source2: sourceValue,
+          resolvedWith: "high-priority-wins"
+        });
+      }
+      resultRecord[section] = sourceValue;
+    }
+  }
+  return resultRecord;
+}
+function mergeConfigSources(sources, options = {}) {
+  const startTime = Date.now();
+  const {
+    validate = true,
+    preserveMetadata: _preserveMetadata = true,
+    conflictStrategy: _conflictStrategy = "high-priority-wins"
+  } = options;
+  const sortedSources = [...sources].sort((a, b) => a.priority - b.priority);
+  if (sortedSources.length === 0) {
+    return {
+      mergedConfig: {},
+      sources: [],
+      conflicts: [],
+      metadata: {
+        mergeTime: Date.now() - startTime,
+        sourcesUsed: 0,
+        conflictsResolved: 0
+      }
+    };
+  }
+  const firstSource = sortedSources[0];
+  if (!firstSource?.data) {
+    return {
+      mergedConfig: {},
+      sources: sortedSources,
+      conflicts: [],
+      metadata: {
+        mergeTime: Date.now() - startTime,
+        sourcesUsed: 0,
+        conflictsResolved: 0
+      }
+    };
+  }
+  const mergedConfig = structuredClone(
+    normalizeLegacyIntoCanonical(firstSource.data)
+  );
+  const conflicts = [];
+  for (let i = 1; i < sortedSources.length; i++) {
+    const source = sortedSources[i];
+    if (!source) continue;
+    const rawSourceData = source.data;
+    if (!rawSourceData) continue;
+    const sourceData = normalizeLegacyIntoCanonical(rawSourceData);
+    if (sourceData.providers) {
+      mergedConfig.providers = mergeProviderConfigs(
+        mergedConfig.providers ?? {},
+        sourceData.providers,
+        conflicts
+      );
+    }
+    if (sourceData.quality) {
+      mergedConfig.quality = mergeQualityConfigs(
+        mergedConfig.quality ?? {},
+        sourceData.quality,
+        conflicts
+      );
+    }
+    for (const [key, value] of Object.entries(sourceData)) {
+      if (key === "providers" || key === "quality") continue;
+      const mergedValue = mergedConfig[key];
+      if (isPlainObject(value) && isPlainObject(mergedValue)) {
+        mergedConfig[key] = deepMerge(
+          mergedValue,
+          value,
+          key,
+          conflicts
+        );
+      } else {
+        if (mergedValue !== void 0 && JSON.stringify(mergedValue) !== JSON.stringify(value)) {
+          const owningSource = [...sortedSources.slice(0, i)].reverse().find((s) => {
+            if (!s.data) return false;
+            return key in s.data;
+          }) ?? sortedSources[0];
+          conflicts.push({
+            key,
+            source1: owningSource,
+            source2: source,
+            resolvedWith: "high-priority-wins"
+          });
+        }
+        mergedConfig[key] = value;
+      }
+    }
+  }
+  const mergeTime = Date.now() - startTime;
+  if (validate) {
+  }
+  const normalizedMergedConfig = normalizeMergedConfigTree(mergedConfig);
+  return {
+    mergedConfig: normalizedMergedConfig,
+    sources: sortedSources,
+    conflicts,
+    metadata: {
+      mergeTime,
+      sourcesUsed: sortedSources.filter((s) => s.data).length,
+      conflictsResolved: conflicts.length
+    }
+  };
+}
+function extractEffectiveCursorModel(config) {
+  if (config.providers?.cursor?.enabled === false) {
+    return void 0;
+  }
+  if (config.providers?.cursor?.model) {
+    return config.providers.cursor.model;
+  }
+  if (config.defaultProvider === "cursor" && config.providers?.cursor) {
+    return config.providers.cursor.model;
+  }
+  return void 0;
+}
+
+// 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 isPlainObject2(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function mergePreferenceValues(existing, incoming) {
+  if (!isPlainObject2(existing) || !isPlainObject2(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 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 replaceUserPreferencesState(snapshot.preferences, filePath);
+  }
+  return mutateUserState(
+    (state) => {
+      for (const key of USER_PREFERENCE_ROOT_KEYS) delete state[key];
+      return null;
+    },
+    {
+      ...filePath ? { filePath } : {},
+      deleteIfEmpty: true
+    }
+  );
+}
+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);
+    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(POETIC_CONFIG_ALLOW_DEFAULT_FALLBACK).value === true;
+  } catch (error) {
+    throw new InvalidExplicitConfigError(
+      `Invalid POETIC_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 existsSync(filePath) ? { status: "present", content: readFileSync(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 = [
+      ...poeticConfigCandidates(paths.projectConfigFile),
+      ...poeticConfigCandidates(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) => existsSync(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 = validatePoeticConfig(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 : validatePoeticConfig(finalConfig, {
+        includeWarnings: true,
+        includeSuggestions: true,
+        cwd: this.options.cwd
+      });
+      if (!finalValidationResult.isValid) {
+        const explicitConfigInvalid = hasExplicitConfigSource(sources) || getConfiguredProviderRegistryPaths(this.options.cwd).some((path) => existsSync(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 InvalidExplicitConfigError(
+            `Invalid explicit Poetic configuration: ${finalValidationResult.errors.map((err) => err.message).join("; ")}`
+          );
+        }
+        finalConfig = cloneConfigValue(DEFAULT_CONFIG);
+      }
+      const isFirstTimeUser = await this.detectFirstTimeUser();
+      const effectiveModel = extractEffectiveCursorModel(finalConfig);
+      const resolvedConfig = {
+        config: finalConfig,
+        sources,
+        effectiveModel,
+        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 (isPoeticConfigReadError(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;
+    }
+  }
+  /**
+   * Update project configuration atomically
+   *
+   * @param config - Configuration to write
+   * @returns Success status
+   */
+  async writeProjectConfig(config) {
+    try {
+      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: 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"
+      };
+    }
+  }
+  /**
+   * Update user configuration atomically (~/.config/poetic/poetic.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: poeticConfigCandidates(this.paths.projectConfigFile).some(configExists)
+      },
+      userConfigFile: {
+        exists: poeticConfigCandidates(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 = validatePoeticConfig(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 'poetic config show' to see valid paths.`
+        };
+      }
+      let config;
+      if (scope === "project") {
+        config = await this.loadProjectConfig() || {};
+      } else {
+        const resolved = await this.loadConfig();
+        const userSource = resolved.sources.find((s) => s.type === "user");
+        config = userSource?.data || {};
+      }
+      const previousValue = this.getNestedValue(config, pathSegments);
+      const parsedValue = this.parseConfigValue(value);
+      const updatedConfig = this.setNestedValue(config, pathSegments, parsedValue);
+      const validationResult = PoeticConfigSchema.safeParse(updatedConfig);
+      if (!validationResult.success) {
+        return {
+          success: false,
+          error: `Invalid configuration: ${validationResult.error.issues.map((issue) => issue.message).join(", ")}`
+        };
+      }
+      const writeResult = await this.writeConfigValuePreservingJsonc(
+        scope,
+        pathSegments,
+        parsedValue,
+        validationResult.data
+      );
+      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 pathSegments = path.split(".").filter(Boolean);
+    let config;
+    if (scope === "project") {
+      config = await this.loadProjectConfig() || {};
+    } else {
+      const resolved = await this.loadConfig();
+      const userSource = resolved.sources.find((s) => s.type === "user");
+      config = userSource?.data || {};
+    }
+    return this.getNestedValue(config, pathSegments);
+  }
+  /**
+   * Validate a configuration path against allowed paths
+   */
+  isValidConfigPath(pathSegments) {
+    const rootNamespace = pathSegments[0];
+    if (!rootNamespace || !KNOWN_POETIC_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;
+  }
+  /**
+   * 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 `{
+  // Poetic configuration.
+  // JSONC is JSON with comments and trailing commas; use "poetic 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) {
+    const filePath = scope === "project" ? this.paths.projectConfigFile : this.paths.userConfigFile;
+    if (!existsSync(filePath)) {
+      return scope === "project" ? this.writeProjectConfig(validatedConfig) : this.writeUserConfig(validatedConfig);
+    }
+    try {
+      const original = readFileSync(filePath, "utf8");
+      const edits = modify(original, pathSegments, value, {
+        formattingOptions: {
+          insertSpaces: true,
+          tabSize: 2
+        }
+      });
+      const updated = applyEdits(original, edits);
+      const result = atomicWrite(filePath, updated.endsWith("\n") ? updated : `${updated}
+`, {
+        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"
+      };
+    }
+  }
+  /**
+   * Reset configuration to defaults
+   *
+   * @param level - Reset level ('user', 'project', or 'all')
+   * @returns Success status
+   */
+  async resetToDefaults(level = "project") {
+    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_POETIC_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 = PoeticConfigSchema.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 {
+  preferencesFromUserState,
+  mutateUserPreferencesState,
+  writeUserPreferencesState,
+  replaceUserPreferencesState,
+  isPlaceholderModelDefault,
+  ConfigManager
+};
+//# sourceMappingURL=chunk-H66DXFS5.js.map