@tuanhung303/opencode-dcp 2.0.0

package/dist/lib/config.js

@@ -0,0 +1,754 @@
+import { readFileSync, writeFileSync, existsSync, mkdirSync, statSync } from "fs";
+import { join, dirname } from "path";
+import { homedir } from "os";
+import { parse } from "jsonc-parser";
+const DEFAULT_PROTECTED_TOOLS = [
+    "task",
+    "todowrite",
+    "todoread",
+    "discard",
+    "extract",
+    "batch",
+    "write",
+    "edit",
+    "plan_enter",
+    "plan_exit",
+];
+// Valid config keys for validation against user config
+export const VALID_CONFIG_KEYS = new Set([
+    // Top-level keys
+    "$schema",
+    "enabled",
+    "debug",
+    "showUpdateToasts", // Deprecated but kept for backwards compatibility
+    "pruneNotification",
+    "turnProtection",
+    "turnProtection.enabled",
+    "turnProtection.turns",
+    "protectedFilePatterns",
+    "commands",
+    "commands.enabled",
+    "commands.protectedTools",
+    "tools",
+    "tools.settings",
+    "tools.settings.nudgeEnabled",
+    "tools.settings.nudgeFrequency",
+    "tools.settings.protectedTools",
+    "tools.discard",
+    "tools.discard.enabled",
+    "tools.extract",
+    "tools.extract.enabled",
+    "tools.extract.showDistillation",
+    "strategies",
+    // strategies.deduplication
+    "strategies.deduplication",
+    "strategies.deduplication.enabled",
+    "strategies.deduplication.protectedTools",
+    // strategies.supersedeWrites
+    "strategies.supersedeWrites",
+    "strategies.supersedeWrites.enabled",
+    // strategies.purgeErrors
+    "strategies.purgeErrors",
+    "strategies.purgeErrors.enabled",
+    "strategies.purgeErrors.turns",
+    "strategies.purgeErrors.protectedTools",
+    // strategies.pruneThinking
+    "strategies.pruneThinking",
+    "strategies.pruneThinking.enabled",
+    "strategies.pruneThinking.delayTurns",
+    // strategies.placeholderCompression
+    "strategies.placeholderCompression",
+    "strategies.placeholderCompression.enabled",
+    "strategies.placeholderCompression.delayTurns",
+    "strategies.placeholderCompression.minOutputTokens",
+    "strategies.placeholderCompression.protectedTools",
+]);
+// Extract all key paths from a config object for validation
+function getConfigKeyPaths(obj, prefix = "") {
+    const keys = [];
+    for (const key of Object.keys(obj)) {
+        const fullKey = prefix ? `${prefix}.${key}` : key;
+        keys.push(fullKey);
+        if (obj[key] && typeof obj[key] === "object" && !Array.isArray(obj[key])) {
+            keys.push(...getConfigKeyPaths(obj[key], fullKey));
+        }
+    }
+    return keys;
+}
+// Returns invalid keys found in user config
+export function getInvalidConfigKeys(userConfig) {
+    const userKeys = getConfigKeyPaths(userConfig);
+    return userKeys.filter((key) => !VALID_CONFIG_KEYS.has(key));
+}
+function validateConfigTypes(config) {
+    const errors = [];
+    // Top-level validators
+    if (config.enabled !== undefined && typeof config.enabled !== "boolean") {
+        errors.push({ key: "enabled", expected: "boolean", actual: typeof config.enabled });
+    }
+    if (config.debug !== undefined && typeof config.debug !== "boolean") {
+        errors.push({ key: "debug", expected: "boolean", actual: typeof config.debug });
+    }
+    if (config.pruneNotification !== undefined) {
+        const validValues = ["off", "minimal", "detailed"];
+        if (!validValues.includes(config.pruneNotification)) {
+            errors.push({
+                key: "pruneNotification",
+                expected: '"off" | "minimal" | "detailed"',
+                actual: JSON.stringify(config.pruneNotification),
+            });
+        }
+    }
+    if (config.protectedFilePatterns !== undefined) {
+        if (!Array.isArray(config.protectedFilePatterns)) {
+            errors.push({
+                key: "protectedFilePatterns",
+                expected: "string[]",
+                actual: typeof config.protectedFilePatterns,
+            });
+        }
+        else if (!config.protectedFilePatterns.every((v) => typeof v === "string")) {
+            errors.push({
+                key: "protectedFilePatterns",
+                expected: "string[]",
+                actual: "non-string entries",
+            });
+        }
+    }
+    // Top-level turnProtection validator
+    if (config.turnProtection) {
+        if (config.turnProtection.enabled !== undefined &&
+            typeof config.turnProtection.enabled !== "boolean") {
+            errors.push({
+                key: "turnProtection.enabled",
+                expected: "boolean",
+                actual: typeof config.turnProtection.enabled,
+            });
+        }
+        if (config.turnProtection.turns !== undefined &&
+            typeof config.turnProtection.turns !== "number") {
+            errors.push({
+                key: "turnProtection.turns",
+                expected: "number",
+                actual: typeof config.turnProtection.turns,
+            });
+        }
+    }
+    // Commands validator
+    const commands = config.commands;
+    if (commands !== undefined) {
+        if (typeof commands === "object") {
+            if (commands.enabled !== undefined && typeof commands.enabled !== "boolean") {
+                errors.push({
+                    key: "commands.enabled",
+                    expected: "boolean",
+                    actual: typeof commands.enabled,
+                });
+            }
+            if (commands.protectedTools !== undefined && !Array.isArray(commands.protectedTools)) {
+                errors.push({
+                    key: "commands.protectedTools",
+                    expected: "string[]",
+                    actual: typeof commands.protectedTools,
+                });
+            }
+        }
+        else {
+            errors.push({
+                key: "commands",
+                expected: "{ enabled: boolean, protectedTools: string[] }",
+                actual: typeof commands,
+            });
+        }
+    }
+    // Tools validators
+    const tools = config.tools;
+    if (tools) {
+        if (tools.settings) {
+            if (tools.settings.nudgeEnabled !== undefined &&
+                typeof tools.settings.nudgeEnabled !== "boolean") {
+                errors.push({
+                    key: "tools.settings.nudgeEnabled",
+                    expected: "boolean",
+                    actual: typeof tools.settings.nudgeEnabled,
+                });
+            }
+            if (tools.settings.nudgeFrequency !== undefined &&
+                typeof tools.settings.nudgeFrequency !== "number") {
+                errors.push({
+                    key: "tools.settings.nudgeFrequency",
+                    expected: "number",
+                    actual: typeof tools.settings.nudgeFrequency,
+                });
+            }
+            if (tools.settings.protectedTools !== undefined &&
+                !Array.isArray(tools.settings.protectedTools)) {
+                errors.push({
+                    key: "tools.settings.protectedTools",
+                    expected: "string[]",
+                    actual: typeof tools.settings.protectedTools,
+                });
+            }
+        }
+        if (tools.discard) {
+            if (tools.discard.enabled !== undefined && typeof tools.discard.enabled !== "boolean") {
+                errors.push({
+                    key: "tools.discard.enabled",
+                    expected: "boolean",
+                    actual: typeof tools.discard.enabled,
+                });
+            }
+        }
+        if (tools.extract) {
+            if (tools.extract.enabled !== undefined && typeof tools.extract.enabled !== "boolean") {
+                errors.push({
+                    key: "tools.extract.enabled",
+                    expected: "boolean",
+                    actual: typeof tools.extract.enabled,
+                });
+            }
+            if (tools.extract.showDistillation !== undefined &&
+                typeof tools.extract.showDistillation !== "boolean") {
+                errors.push({
+                    key: "tools.extract.showDistillation",
+                    expected: "boolean",
+                    actual: typeof tools.extract.showDistillation,
+                });
+            }
+        }
+    }
+    // Strategies validators
+    const strategies = config.strategies;
+    if (strategies) {
+        // deduplication
+        if (strategies.deduplication?.enabled !== undefined &&
+            typeof strategies.deduplication.enabled !== "boolean") {
+            errors.push({
+                key: "strategies.deduplication.enabled",
+                expected: "boolean",
+                actual: typeof strategies.deduplication.enabled,
+            });
+        }
+        if (strategies.deduplication?.protectedTools !== undefined &&
+            !Array.isArray(strategies.deduplication.protectedTools)) {
+            errors.push({
+                key: "strategies.deduplication.protectedTools",
+                expected: "string[]",
+                actual: typeof strategies.deduplication.protectedTools,
+            });
+        }
+        // supersedeWrites
+        if (strategies.supersedeWrites) {
+            if (strategies.supersedeWrites.enabled !== undefined &&
+                typeof strategies.supersedeWrites.enabled !== "boolean") {
+                errors.push({
+                    key: "strategies.supersedeWrites.enabled",
+                    expected: "boolean",
+                    actual: typeof strategies.supersedeWrites.enabled,
+                });
+            }
+        }
+        // purgeErrors
+        if (strategies.purgeErrors) {
+            if (strategies.purgeErrors.enabled !== undefined &&
+                typeof strategies.purgeErrors.enabled !== "boolean") {
+                errors.push({
+                    key: "strategies.purgeErrors.enabled",
+                    expected: "boolean",
+                    actual: typeof strategies.purgeErrors.enabled,
+                });
+            }
+            if (strategies.purgeErrors.turns !== undefined &&
+                typeof strategies.purgeErrors.turns !== "number") {
+                errors.push({
+                    key: "strategies.purgeErrors.turns",
+                    expected: "number",
+                    actual: typeof strategies.purgeErrors.turns,
+                });
+            }
+            if (strategies.purgeErrors.protectedTools !== undefined &&
+                !Array.isArray(strategies.purgeErrors.protectedTools)) {
+                errors.push({
+                    key: "strategies.purgeErrors.protectedTools",
+                    expected: "string[]",
+                    actual: typeof strategies.purgeErrors.protectedTools,
+                });
+            }
+        }
+        // pruneThinking
+        if (strategies.pruneThinking) {
+            if (strategies.pruneThinking.enabled !== undefined &&
+                typeof strategies.pruneThinking.enabled !== "boolean") {
+                errors.push({
+                    key: "strategies.pruneThinking.enabled",
+                    expected: "boolean",
+                    actual: typeof strategies.pruneThinking.enabled,
+                });
+            }
+            if (strategies.pruneThinking.delayTurns !== undefined &&
+                typeof strategies.pruneThinking.delayTurns !== "number") {
+                errors.push({
+                    key: "strategies.pruneThinking.delayTurns",
+                    expected: "number",
+                    actual: typeof strategies.pruneThinking.delayTurns,
+                });
+            }
+        }
+        // placeholderCompression
+        if (strategies.placeholderCompression) {
+            if (strategies.placeholderCompression.enabled !== undefined &&
+                typeof strategies.placeholderCompression.enabled !== "boolean") {
+                errors.push({
+                    key: "strategies.placeholderCompression.enabled",
+                    expected: "boolean",
+                    actual: typeof strategies.placeholderCompression.enabled,
+                });
+            }
+            if (strategies.placeholderCompression.delayTurns !== undefined &&
+                typeof strategies.placeholderCompression.delayTurns !== "number") {
+                errors.push({
+                    key: "strategies.placeholderCompression.delayTurns",
+                    expected: "number",
+                    actual: typeof strategies.placeholderCompression.delayTurns,
+                });
+            }
+            if (strategies.placeholderCompression.minOutputTokens !== undefined &&
+                typeof strategies.placeholderCompression.minOutputTokens !== "number") {
+                errors.push({
+                    key: "strategies.placeholderCompression.minOutputTokens",
+                    expected: "number",
+                    actual: typeof strategies.placeholderCompression.minOutputTokens,
+                });
+            }
+            if (strategies.placeholderCompression.protectedTools !== undefined &&
+                !Array.isArray(strategies.placeholderCompression.protectedTools)) {
+                errors.push({
+                    key: "strategies.placeholderCompression.protectedTools",
+                    expected: "string[]",
+                    actual: typeof strategies.placeholderCompression.protectedTools,
+                });
+            }
+        }
+    }
+    return errors;
+}
+// Show validation warnings for a config file
+function showConfigValidationWarnings(ctx, configPath, configData, isProject) {
+    const invalidKeys = getInvalidConfigKeys(configData);
+    const typeErrors = validateConfigTypes(configData);
+    if (invalidKeys.length === 0 && typeErrors.length === 0) {
+        return;
+    }
+    const configType = isProject ? "project config" : "config";
+    const messages = [];
+    if (invalidKeys.length > 0) {
+        const keyList = invalidKeys.slice(0, 3).join(", ");
+        const suffix = invalidKeys.length > 3 ? ` (+${invalidKeys.length - 3} more)` : "";
+        messages.push(`Unknown keys: ${keyList}${suffix}`);
+    }
+    if (typeErrors.length > 0) {
+        for (const err of typeErrors.slice(0, 2)) {
+            messages.push(`${err.key}: expected ${err.expected}, got ${err.actual}`);
+        }
+        if (typeErrors.length > 2) {
+            messages.push(`(+${typeErrors.length - 2} more type errors)`);
+        }
+    }
+    setTimeout(() => {
+        try {
+            ctx.client.tui.showToast({
+                body: {
+                    title: `DCP: Invalid ${configType}`,
+                    message: `${configPath}\n${messages.join("\n")}`,
+                    variant: "warning",
+                    duration: 7000,
+                },
+            });
+        }
+        catch { }
+    }, 7000);
+}
+export const DEFAULT_CONFIG = {
+    enabled: true,
+    debug: false,
+    pruneNotification: "detailed",
+    commands: {
+        enabled: true,
+        protectedTools: [...DEFAULT_PROTECTED_TOOLS],
+    },
+    turnProtection: {
+        enabled: false,
+        turns: 4,
+    },
+    protectedFilePatterns: [],
+    tools: {
+        settings: {
+            nudgeEnabled: true,
+            nudgeFrequency: 5,
+            protectedTools: [...DEFAULT_PROTECTED_TOOLS],
+        },
+        discard: {
+            enabled: true,
+        },
+        extract: {
+            enabled: true,
+            showDistillation: false,
+        },
+    },
+    strategies: {
+        deduplication: {
+            enabled: true,
+            protectedTools: [],
+        },
+        supersedeWrites: {
+            enabled: true,
+        },
+        purgeErrors: {
+            enabled: true,
+            turns: 2,
+            protectedTools: [],
+        },
+        pruneThinking: {
+            enabled: true,
+            delayTurns: 1,
+        },
+        placeholderCompression: {
+            enabled: true,
+            delayTurns: 2,
+            minOutputTokens: 100,
+            protectedTools: [],
+        },
+    },
+};
+const GLOBAL_CONFIG_DIR = join(homedir(), ".config", "opencode");
+const GLOBAL_CONFIG_PATH_JSONC = join(GLOBAL_CONFIG_DIR, "dcp.jsonc");
+const GLOBAL_CONFIG_PATH_JSON = join(GLOBAL_CONFIG_DIR, "dcp.json");
+function findOpencodeDir(startDir) {
+    let current = startDir;
+    while (current !== "/") {
+        const candidate = join(current, ".opencode");
+        if (existsSync(candidate) && statSync(candidate).isDirectory()) {
+            return candidate;
+        }
+        const parent = dirname(current);
+        if (parent === current)
+            break;
+        current = parent;
+    }
+    return null;
+}
+function getConfigPaths(ctx) {
+    // Global: ~/.config/opencode/dcp.jsonc|json
+    let globalPath = null;
+    if (existsSync(GLOBAL_CONFIG_PATH_JSONC)) {
+        globalPath = GLOBAL_CONFIG_PATH_JSONC;
+    }
+    else if (existsSync(GLOBAL_CONFIG_PATH_JSON)) {
+        globalPath = GLOBAL_CONFIG_PATH_JSON;
+    }
+    // Custom config directory: $OPENCODE_CONFIG_DIR/dcp.jsonc|json
+    let configDirPath = null;
+    const opencodeConfigDir = process.env.OPENCODE_CONFIG_DIR;
+    if (opencodeConfigDir) {
+        const configJsonc = join(opencodeConfigDir, "dcp.jsonc");
+        const configJson = join(opencodeConfigDir, "dcp.json");
+        if (existsSync(configJsonc)) {
+            configDirPath = configJsonc;
+        }
+        else if (existsSync(configJson)) {
+            configDirPath = configJson;
+        }
+    }
+    // Project: <project>/.opencode/dcp.jsonc|json
+    let projectPath = null;
+    if (ctx?.directory) {
+        const opencodeDir = findOpencodeDir(ctx.directory);
+        if (opencodeDir) {
+            const projectJsonc = join(opencodeDir, "dcp.jsonc");
+            const projectJson = join(opencodeDir, "dcp.json");
+            if (existsSync(projectJsonc)) {
+                projectPath = projectJsonc;
+            }
+            else if (existsSync(projectJson)) {
+                projectPath = projectJson;
+            }
+        }
+    }
+    return { global: globalPath, configDir: configDirPath, project: projectPath };
+}
+function createDefaultConfig() {
+    if (!existsSync(GLOBAL_CONFIG_DIR)) {
+        mkdirSync(GLOBAL_CONFIG_DIR, { recursive: true });
+    }
+    const configContent = `{
+  "$schema": "https://raw.githubusercontent.com/Opencode-DCP/opencode-dynamic-context-pruning/master/dcp.schema.json"
+}
+`;
+    writeFileSync(GLOBAL_CONFIG_PATH_JSONC, configContent, "utf-8");
+}
+function loadConfigFile(configPath) {
+    let fileContent;
+    try {
+        fileContent = readFileSync(configPath, "utf-8");
+    }
+    catch {
+        // File doesn't exist or can't be read - not a parse error
+        return { data: null };
+    }
+    try {
+        const parsed = parse(fileContent);
+        if (parsed === undefined || parsed === null) {
+            return { data: null, parseError: "Config file is empty or invalid" };
+        }
+        return { data: parsed };
+    }
+    catch (error) {
+        return { data: null, parseError: error.message || "Failed to parse config" };
+    }
+}
+function mergeStrategies(base, override) {
+    if (!override)
+        return base;
+    return {
+        deduplication: {
+            enabled: override.deduplication?.enabled ?? base.deduplication.enabled,
+            protectedTools: [
+                ...new Set([
+                    ...base.deduplication.protectedTools,
+                    ...(override.deduplication?.protectedTools ?? []),
+                ]),
+            ],
+        },
+        supersedeWrites: {
+            enabled: override.supersedeWrites?.enabled ?? base.supersedeWrites.enabled,
+        },
+        purgeErrors: {
+            enabled: override.purgeErrors?.enabled ?? base.purgeErrors.enabled,
+            turns: override.purgeErrors?.turns ?? base.purgeErrors.turns,
+            protectedTools: [
+                ...new Set([
+                    ...base.purgeErrors.protectedTools,
+                    ...(override.purgeErrors?.protectedTools ?? []),
+                ]),
+            ],
+        },
+        pruneThinking: {
+            enabled: override.pruneThinking?.enabled ?? base.pruneThinking.enabled,
+            delayTurns: override.pruneThinking?.delayTurns ?? base.pruneThinking.delayTurns,
+        },
+        placeholderCompression: {
+            enabled: override.placeholderCompression?.enabled ?? base.placeholderCompression.enabled,
+            delayTurns: override.placeholderCompression?.delayTurns ?? base.placeholderCompression.delayTurns,
+            minOutputTokens: override.placeholderCompression?.minOutputTokens ?? base.placeholderCompression.minOutputTokens,
+            protectedTools: [
+                ...new Set([
+                    ...base.placeholderCompression.protectedTools,
+                    ...(override.placeholderCompression?.protectedTools ?? []),
+                ]),
+            ],
+        },
+    };
+}
+function mergeTools(base, override) {
+    if (!override)
+        return base;
+    return {
+        settings: {
+            nudgeEnabled: override.settings?.nudgeEnabled ?? base.settings.nudgeEnabled,
+            nudgeFrequency: override.settings?.nudgeFrequency ?? base.settings.nudgeFrequency,
+            protectedTools: [
+                ...new Set([
+                    ...base.settings.protectedTools,
+                    ...(override.settings?.protectedTools ?? []),
+                ]),
+            ],
+        },
+        discard: {
+            enabled: override.discard?.enabled ?? base.discard.enabled,
+        },
+        extract: {
+            enabled: override.extract?.enabled ?? base.extract.enabled,
+            showDistillation: override.extract?.showDistillation ?? base.extract.showDistillation,
+        },
+    };
+}
+function mergeCommands(base, override) {
+    if (override === undefined)
+        return base;
+    return {
+        enabled: override.enabled ?? base.enabled,
+        protectedTools: [...new Set([...base.protectedTools, ...(override.protectedTools ?? [])])],
+    };
+}
+function deepCloneConfig(config) {
+    return {
+        ...config,
+        commands: {
+            enabled: config.commands.enabled,
+            protectedTools: [...config.commands.protectedTools],
+        },
+        turnProtection: { ...config.turnProtection },
+        protectedFilePatterns: [...config.protectedFilePatterns],
+        tools: {
+            settings: {
+                ...config.tools.settings,
+                protectedTools: [...config.tools.settings.protectedTools],
+            },
+            discard: { ...config.tools.discard },
+            extract: { ...config.tools.extract },
+        },
+        strategies: {
+            deduplication: {
+                ...config.strategies.deduplication,
+                protectedTools: [...config.strategies.deduplication.protectedTools],
+            },
+            supersedeWrites: {
+                ...config.strategies.supersedeWrites,
+            },
+            purgeErrors: {
+                ...config.strategies.purgeErrors,
+                protectedTools: [...config.strategies.purgeErrors.protectedTools],
+            },
+            pruneThinking: {
+                ...config.strategies.pruneThinking,
+            },
+            placeholderCompression: {
+                ...config.strategies.placeholderCompression,
+                protectedTools: [...config.strategies.placeholderCompression.protectedTools],
+            },
+        },
+    };
+}
+export function getConfig(ctx) {
+    let config = deepCloneConfig(DEFAULT_CONFIG);
+    const configPaths = getConfigPaths(ctx);
+    // Load and merge global config
+    if (configPaths.global) {
+        const result = loadConfigFile(configPaths.global);
+        if (result.parseError) {
+            setTimeout(async () => {
+                try {
+                    ctx.client.tui.showToast({
+                        body: {
+                            title: "DCP: Invalid config",
+                            message: `${configPaths.global}\n${result.parseError}\nUsing default values`,
+                            variant: "warning",
+                            duration: 7000,
+                        },
+                    });
+                }
+                catch { }
+            }, 7000);
+        }
+        else if (result.data) {
+            // Validate config keys and types
+            showConfigValidationWarnings(ctx, configPaths.global, result.data, false);
+            config = {
+                enabled: result.data.enabled ?? config.enabled,
+                debug: result.data.debug ?? config.debug,
+                pruneNotification: result.data.pruneNotification ?? config.pruneNotification,
+                commands: mergeCommands(config.commands, result.data.commands),
+                turnProtection: {
+                    enabled: result.data.turnProtection?.enabled ?? config.turnProtection.enabled,
+                    turns: result.data.turnProtection?.turns ?? config.turnProtection.turns,
+                },
+                protectedFilePatterns: [
+                    ...new Set([
+                        ...config.protectedFilePatterns,
+                        ...(result.data.protectedFilePatterns ?? []),
+                    ]),
+                ],
+                tools: mergeTools(config.tools, result.data.tools),
+                strategies: mergeStrategies(config.strategies, result.data.strategies),
+            };
+        }
+    }
+    else {
+        // No config exists, create default
+        createDefaultConfig();
+    }
+    // Load and merge $OPENCODE_CONFIG_DIR/dcp.jsonc|json (overrides global)
+    if (configPaths.configDir) {
+        const result = loadConfigFile(configPaths.configDir);
+        if (result.parseError) {
+            setTimeout(async () => {
+                try {
+                    ctx.client.tui.showToast({
+                        body: {
+                            title: "DCP: Invalid configDir config",
+                            message: `${configPaths.configDir}\n${result.parseError}\nUsing global/default values`,
+                            variant: "warning",
+                            duration: 7000,
+                        },
+                    });
+                }
+                catch { }
+            }, 7000);
+        }
+        else if (result.data) {
+            // Validate config keys and types
+            showConfigValidationWarnings(ctx, configPaths.configDir, result.data, true);
+            config = {
+                enabled: result.data.enabled ?? config.enabled,
+                debug: result.data.debug ?? config.debug,
+                pruneNotification: result.data.pruneNotification ?? config.pruneNotification,
+                commands: mergeCommands(config.commands, result.data.commands),
+                turnProtection: {
+                    enabled: result.data.turnProtection?.enabled ?? config.turnProtection.enabled,
+                    turns: result.data.turnProtection?.turns ?? config.turnProtection.turns,
+                },
+                protectedFilePatterns: [
+                    ...new Set([
+                        ...config.protectedFilePatterns,
+                        ...(result.data.protectedFilePatterns ?? []),
+                    ]),
+                ],
+                tools: mergeTools(config.tools, result.data.tools),
+                strategies: mergeStrategies(config.strategies, result.data.strategies),
+            };
+        }
+    }
+    // Load and merge project config (overrides global)
+    if (configPaths.project) {
+        const result = loadConfigFile(configPaths.project);
+        if (result.parseError) {
+            setTimeout(async () => {
+                try {
+                    ctx.client.tui.showToast({
+                        body: {
+                            title: "DCP: Invalid project config",
+                            message: `${configPaths.project}\n${result.parseError}\nUsing global/default values`,
+                            variant: "warning",
+                            duration: 7000,
+                        },
+                    });
+                }
+                catch { }
+            }, 7000);
+        }
+        else if (result.data) {
+            // Validate config keys and types
+            showConfigValidationWarnings(ctx, configPaths.project, result.data, true);
+            config = {
+                enabled: result.data.enabled ?? config.enabled,
+                debug: result.data.debug ?? config.debug,
+                pruneNotification: result.data.pruneNotification ?? config.pruneNotification,
+                commands: mergeCommands(config.commands, result.data.commands),
+                turnProtection: {
+                    enabled: result.data.turnProtection?.enabled ?? config.turnProtection.enabled,
+                    turns: result.data.turnProtection?.turns ?? config.turnProtection.turns,
+                },
+                protectedFilePatterns: [
+                    ...new Set([
+                        ...config.protectedFilePatterns,
+                        ...(result.data.protectedFilePatterns ?? []),
+                    ]),
+                ],
+                tools: mergeTools(config.tools, result.data.tools),
+                strategies: mergeStrategies(config.strategies, result.data.strategies),
+            };
+        }
+    }
+    return config;
+}
+//# sourceMappingURL=config.js.map