import { defaultsToThinkingMode } from "./common/model-capabilities";

export type DeepcodingEnv = Record<string, string | undefined> & {

MODEL?: string;

BASE_URL?: string;

API_KEY?: string;

THINKING_ENABLED?: string;

REASONING_EFFORT?: string;

DEBUG_LOG_ENABLED?: string;

};

export type ReasoningEffort = "high" | "max";

export type McpServerConfig = {

command: string;

args?: string[];

env?: Record<string, string>;

};

export type DeepcodingSettings = {

env?: DeepcodingEnv;

model?: string;

thinkingEnabled?: boolean;

reasoningEffort?: ReasoningEffort;

debugLogEnabled?: boolean;

notify?: string;

webSearchTool?: string;

mcpServers?: Record<string, McpServerConfig>;

};

export type ResolvedDeepcodingSettings = {

env: Record<string, string>;

apiKey?: string;

baseURL: string;

model: string;

thinkingEnabled: boolean;

reasoningEffort: ReasoningEffort;

debugLogEnabled: boolean;

notify?: string;

webSearchTool?: string;

mcpServers?: Record<string, McpServerConfig>;

};

export type ModelConfigSelection = {

model: string;

thinkingEnabled: boolean;

reasoningEffort: ReasoningEffort;

};

export type SettingsProcessEnv = Record<string, string | undefined>;

function resolveReasoningEffort(value: unknown): ReasoningEffort | undefined {

return value === "high" || value === "max" ? value : undefined;

}

function parseBoolean(value: unknown): boolean | undefined {

if (typeof value === "boolean") {

return value;

}

if (typeof value !== "string") {

return undefined;

}

const normalized = value.trim().toLowerCase();

if (["1", "true", "enabled", "yes", "on"].includes(normalized)) {

return true;

}

if (["0", "false", "disabled", "no", "off"].includes(normalized)) {

return false;

}

return undefined;

}

function trimString(value: unknown): string {

return typeof value === "string" ? value.trim() : "";

}

function normalizeEnv(env: DeepcodingSettings["env"]): Record<string, string> {

const result: Record<string, string> = {};

if (!env) {

return result;

}

for (const [key, value] of Object.entries(env)) {

if (typeof value === "string") {

result[key] = value;

}

}

return result;

}

export function collectDeepcodeEnv(processEnv: SettingsProcessEnv = process.env): Record<string, string> {

const result: Record<string, string> = {};

for (const [key, value] of Object.entries(processEnv)) {

if (!key.startsWith("DEEPCODE_") || typeof value !== "string") {

continue;

}

const strippedKey = key.slice("DEEPCODE_".length);

if (strippedKey) {

result[strippedKey] = value;

}

}

return result;

}

function extractMcpEnv(env: Record<string, string>): Record<string, string> {

const result: Record<string, string> = {};

for (const [key, value] of Object.entries(env)) {

if (!key.startsWith("MCP_")) {

continue;

}

const strippedKey = key.slice("MCP_".length);

if (strippedKey) {

result[strippedKey] = value;

}

}

return result;

}

function mergeMcpServers(

userSettings: DeepcodingSettings | null | undefined,

projectSettings: DeepcodingSettings | null | undefined,

userEnv: Record<string, string>,

projectEnv: Record<string, string>,

systemEnv: Record<string, string>

): Record<string, McpServerConfig> | undefined {

const userServers = userSettings?.mcpServers ?? {};

const projectServers = projectSettings?.mcpServers ?? {};

const serverNames = new Set([...Object.keys(userServers), ...Object.keys(projectServers)]);

if (serverNames.size === 0) {

return undefined;

}

const userMcpEnv = extractMcpEnv(userEnv);

const projectMcpEnv = extractMcpEnv(projectEnv);

const systemMcpEnv = extractMcpEnv(systemEnv);

const merged: Record<string, McpServerConfig> = {};

for (const name of serverNames) {

const userConfig = userServers[name];

const projectConfig = projectServers[name];

const command = projectConfig?.command ?? userConfig?.command;

if (!command) {

continue;

}

const env = {

...userEnv,

...(userConfig?.env ?? {}),

...userMcpEnv,

...projectEnv,

...(projectConfig?.env ?? {}),

...projectMcpEnv,

...systemEnv,

...systemMcpEnv,

};

const config: McpServerConfig = {

command,

args: projectConfig?.args ?? userConfig?.args,

};

if (Object.keys(env).length > 0) {

config.env = env;

}

merged[name] = config;

}

return Object.keys(merged).length > 0 ? merged : undefined;

}

export function resolveSettingsSources(

userSettings: DeepcodingSettings | null | undefined,

projectSettings: DeepcodingSettings | null | undefined,

defaults: { model: string; baseURL: string },

processEnv: SettingsProcessEnv = process.env

): ResolvedDeepcodingSettings {

const userEnv = normalizeEnv(userSettings?.env);

const projectEnv = normalizeEnv(projectSettings?.env);

const systemEnv = collectDeepcodeEnv(processEnv);

const env = {

...userEnv,

...projectEnv,

...systemEnv,

};

const model =

trimString(systemEnv.MODEL) ||

trimString(projectSettings?.model) ||

trimString(projectEnv.MODEL) ||

trimString(userSettings?.model) ||

trimString(userEnv.MODEL) ||

defaults.model;

const thinkingEnabled =

parseBoolean(systemEnv.THINKING_ENABLED) ??

parseBoolean(projectSettings?.thinkingEnabled) ??

parseBoolean(projectEnv.THINKING_ENABLED) ??

parseBoolean(userSettings?.thinkingEnabled) ??

parseBoolean(userEnv.THINKING_ENABLED) ??

defaultsToThinkingMode(model);

const reasoningEffort =

resolveReasoningEffort(systemEnv.REASONING_EFFORT) ??

resolveReasoningEffort(projectSettings?.reasoningEffort) ??

resolveReasoningEffort(projectEnv.REASONING_EFFORT) ??

resolveReasoningEffort(userSettings?.reasoningEffort) ??

resolveReasoningEffort(userEnv.REASONING_EFFORT) ??

"max";

const debugLogEnabled =

parseBoolean(systemEnv.DEBUG_LOG_ENABLED) ??

parseBoolean(projectSettings?.debugLogEnabled) ??

parseBoolean(projectEnv.DEBUG_LOG_ENABLED) ??

parseBoolean(userSettings?.debugLogEnabled) ??

parseBoolean(userEnv.DEBUG_LOG_ENABLED) ??

false;

const notify =

trimString(systemEnv.NOTIFY) || trimString(projectSettings?.notify) || trimString(userSettings?.notify) || "";

const webSearchTool =

trimString(systemEnv.WEB_SEARCH_TOOL) ||

trimString(projectSettings?.webSearchTool) ||

trimString(userSettings?.webSearchTool) ||

"";

return {

env,

apiKey: trimString(env.API_KEY) || undefined,

baseURL: trimString(env.BASE_URL) || defaults.baseURL,

model,

thinkingEnabled,

reasoningEffort,

debugLogEnabled,

notify: notify || undefined,

webSearchTool: webSearchTool || undefined,

mcpServers: mergeMcpServers(userSettings, projectSettings, userEnv, projectEnv, systemEnv),

};

}

export function resolveSettings(

settings: DeepcodingSettings | null | undefined,

defaults: { model: string; baseURL: string },

processEnv: SettingsProcessEnv = process.env

): ResolvedDeepcodingSettings {

return resolveSettingsSources(settings, null, defaults, processEnv);

}

export function modelConfigKey(config: Pick<ModelConfigSelection, "thinkingEnabled" | "reasoningEffort">): string {

return config.thinkingEnabled ? `thinking:${config.reasoningEffort}` : "thinking:none";

}

export function applyModelConfigSelection(

settings: DeepcodingSettings | null | undefined,

current: ModelConfigSelection,

selected: ModelConfigSelection

): { settings: DeepcodingSettings; changed: boolean } {

const changed = selected.model !== current.model || modelConfigKey(selected) !== modelConfigKey(current);

const next: DeepcodingSettings = { ...(settings ?? {}) };

if (!changed) {

return { settings: next, changed: false };

}

if (selected.model !== current.model || Object.prototype.hasOwnProperty.call(next, "model")) {

next.model = selected.model;

} else {

delete next.model;

}

next.thinkingEnabled = selected.thinkingEnabled;

if (selected.thinkingEnabled) {

next.reasoningEffort = selected.reasoningEffort;

}

return { settings: next, changed: true };

}