Reorganize modules into layered directories

llm/llm-preset-utils.js

@@ -0,0 +1,165 @@
+function normalizeLlmConfigValue(value) {
+  return String(value || "").trim();
+}
+
+export function createLlmConfigSnapshot(source = {}) {
+  return {
+    llmApiUrl: normalizeLlmConfigValue(source?.llmApiUrl),
+    llmApiKey: normalizeLlmConfigValue(source?.llmApiKey),
+    llmModel: normalizeLlmConfigValue(source?.llmModel),
+  };
+}
+
+export function isUsableLlmConfigSnapshot(snapshot = {}) {
+  const normalized = createLlmConfigSnapshot(snapshot);
+  return Boolean(normalized.llmApiUrl && normalized.llmModel);
+}
+
+export function isSameLlmConfigSnapshot(left = {}, right = {}) {
+  const normalizedLeft = createLlmConfigSnapshot(left);
+  const normalizedRight = createLlmConfigSnapshot(right);
+  return (
+    normalizedLeft.llmApiUrl === normalizedRight.llmApiUrl &&
+    normalizedLeft.llmApiKey === normalizedRight.llmApiKey &&
+    normalizedLeft.llmModel === normalizedRight.llmModel
+  );
+}
+
+export function normalizeLlmPresetMap(rawPresets = {}) {
+  const normalizedPresets = {};
+  let changed =
+    !rawPresets ||
+    typeof rawPresets !== "object" ||
+    Array.isArray(rawPresets);
+
+  if (!changed) {
+    for (const [name, preset] of Object.entries(rawPresets)) {
+      const normalizedName = String(name || "").trim();
+      if (!normalizedName) {
+        changed = true;
+        continue;
+      }
+      if (
+        !preset ||
+        typeof preset !== "object" ||
+        Array.isArray(preset) ||
+        typeof preset.llmApiUrl !== "string" ||
+        typeof preset.llmApiKey !== "string" ||
+        typeof preset.llmModel !== "string"
+      ) {
+        changed = true;
+        continue;
+      }
+      normalizedPresets[normalizedName] = {
+        llmApiUrl: normalizeLlmConfigValue(preset.llmApiUrl),
+        llmApiKey: normalizeLlmConfigValue(preset.llmApiKey),
+        llmModel: normalizeLlmConfigValue(preset.llmModel),
+      };
+      if (normalizedName !== name) {
+        changed = true;
+      }
+    }
+  }
+
+  return {
+    presets: normalizedPresets,
+    changed,
+  };
+}
+
+export function sanitizeLlmPresetSettings(settings = {}) {
+  const normalized = settings && typeof settings === "object" ? settings : {};
+  const { presets, changed: presetChanged } = normalizeLlmPresetMap(
+    normalized.llmPresets,
+  );
+  let activePreset =
+    typeof normalized.llmActivePreset === "string"
+      ? normalized.llmActivePreset
+      : "";
+  let changed = presetChanged || typeof normalized.llmActivePreset !== "string";
+
+  if (
+    activePreset &&
+    !Object.prototype.hasOwnProperty.call(presets, activePreset)
+  ) {
+    activePreset = "";
+    changed = true;
+  }
+
+  return {
+    presets,
+    activePreset,
+    changed,
+  };
+}
+
+export function resolveActiveLlmPresetName(settings = {}) {
+  const normalized = settings && typeof settings === "object" ? settings : {};
+  const { presets, activePreset } = sanitizeLlmPresetSettings(normalized);
+  const snapshot = createLlmConfigSnapshot(normalized);
+
+  if (
+    activePreset &&
+    presets[activePreset] &&
+    isSameLlmConfigSnapshot(snapshot, presets[activePreset])
+  ) {
+    return activePreset;
+  }
+
+  const matchingPresets = Object.keys(presets).filter((name) =>
+    isSameLlmConfigSnapshot(snapshot, presets[name]),
+  );
+
+  if (matchingPresets.length === 1) {
+    return matchingPresets[0];
+  }
+
+  return "";
+}
+
+export function resolveLlmConfigSelection(settings = {}, selectedPresetName = "") {
+  const normalized = settings && typeof settings === "object" ? settings : {};
+  const { presets } = sanitizeLlmPresetSettings(normalized);
+  const globalConfig = createLlmConfigSnapshot(normalized);
+  const requestedPresetName = normalizeLlmConfigValue(selectedPresetName);
+
+  if (!requestedPresetName) {
+    return {
+      source: "global",
+      config: globalConfig,
+      requestedPresetName: "",
+      presetName: "",
+      fallbackReason: "",
+    };
+  }
+
+  const presetConfig = presets[requestedPresetName];
+  if (!presetConfig) {
+    return {
+      source: "global-fallback-missing-task-preset",
+      config: globalConfig,
+      requestedPresetName,
+      presetName: "",
+      fallbackReason: "selected_task_preset_missing",
+    };
+  }
+
+  const normalizedPresetConfig = createLlmConfigSnapshot(presetConfig);
+  if (!isUsableLlmConfigSnapshot(normalizedPresetConfig)) {
+    return {
+      source: "global-fallback-invalid-task-preset",
+      config: globalConfig,
+      requestedPresetName,
+      presetName: "",
+      fallbackReason: "selected_task_preset_incomplete",
+    };
+  }
+
+  return {
+    source: "task-preset",
+    config: normalizedPresetConfig,
+    requestedPresetName,
+    presetName: requestedPresetName,
+    fallbackReason: "",
+  };
+}