opencode-recall 0.1.0

package/dist/lib/config.js

@@ -0,0 +1,779 @@
+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",
+    "rcl_explore",
+    "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",
+    "explore",
+    "explore.enabled",
+    "explore.agentModel",
+    "explore.agentVariant",
+    "explore.timeoutMs",
+    "explore.maxResultChars",
+    "tools",
+    "tools.settings",
+    "tools.settings.nudgeEnabled",
+    "tools.settings.nudgeFrequency",
+    "tools.settings.restoreProtectionTurns",
+    "tools.settings.restoreMaxBytes",
+    "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",
+]);
+// 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",
+            });
+        }
+    }
+    // Explore (sub-agent) validators
+    if (config.explore) {
+        if (config.explore.enabled !== undefined && typeof config.explore.enabled !== "boolean") {
+            errors.push({
+                key: "explore.enabled",
+                expected: "boolean",
+                actual: typeof config.explore.enabled,
+            });
+        }
+        if (config.explore.agentModel !== undefined &&
+            typeof config.explore.agentModel !== "string") {
+            errors.push({
+                key: "explore.agentModel",
+                expected: "string",
+                actual: typeof config.explore.agentModel,
+            });
+        }
+        if (config.explore.agentVariant !== undefined &&
+            typeof config.explore.agentVariant !== "string") {
+            errors.push({
+                key: "explore.agentVariant",
+                expected: "string",
+                actual: typeof config.explore.agentVariant,
+            });
+        }
+        if (config.explore.timeoutMs !== undefined &&
+            typeof config.explore.timeoutMs !== "number") {
+            errors.push({
+                key: "explore.timeoutMs",
+                expected: "number",
+                actual: typeof config.explore.timeoutMs,
+            });
+        }
+        if (config.explore.maxResultChars !== undefined &&
+            typeof config.explore.maxResultChars !== "number") {
+            errors.push({
+                key: "explore.maxResultChars",
+                expected: "number",
+                actual: typeof config.explore.maxResultChars,
+            });
+        }
+    }
+    // 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,
+            });
+        }
+    }
+    // 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.restoreProtectionTurns !== undefined &&
+                typeof tools.settings.restoreProtectionTurns !== "number") {
+                errors.push({
+                    key: "tools.settings.restoreProtectionTurns",
+                    expected: "number",
+                    actual: typeof tools.settings.restoreProtectionTurns,
+                });
+            }
+            if (tools.settings.restoreMaxBytes !== undefined &&
+                typeof tools.settings.restoreMaxBytes !== "number") {
+                errors.push({
+                    key: "tools.settings.restoreMaxBytes",
+                    expected: "number",
+                    actual: typeof tools.settings.restoreMaxBytes,
+                });
+            }
+            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,
+                });
+            }
+        }
+    }
+    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: `RCL: Invalid ${configType}`,
+                    message: `${configPath}\n${messages.join("\n")}`,
+                    variant: "warning",
+                    duration: 7000,
+                },
+            });
+        }
+        catch { }
+    }, 7000);
+}
+const defaultConfig = {
+    enabled: true,
+    debug: false,
+    pruneNotification: "detailed",
+    turnProtection: {
+        enabled: false,
+        turns: 4,
+    },
+    protectedFilePatterns: [],
+    explore: {
+        enabled: true,
+        // When omitted, Recall will infer a model from your OpenCode agent config.
+        agentModel: undefined,
+        // Keep this low by default - rcl_explore is meant to be cheap.
+        agentVariant: "low",
+        timeoutMs: 120_000,
+        maxResultChars: 4000,
+    },
+    tools: {
+        settings: {
+            nudgeEnabled: true,
+            nudgeFrequency: 10,
+            restoreProtectionTurns: 4,
+            restoreMaxBytes: 8000,
+            protectedTools: [...DEFAULT_PROTECTED_TOOLS],
+        },
+        discard: {
+            enabled: true,
+        },
+        extract: {
+            enabled: true,
+            showDistillation: false,
+        },
+    },
+    strategies: {
+        deduplication: {
+            enabled: true,
+            protectedTools: [...DEFAULT_PROTECTED_TOOLS],
+        },
+        supersedeWrites: {
+            enabled: true,
+        },
+        purgeErrors: {
+            enabled: true,
+            turns: 4,
+            protectedTools: [...DEFAULT_PROTECTED_TOOLS],
+        },
+    },
+};
+const GLOBAL_CONFIG_DIR = join(homedir(), ".config", "opencode");
+const GLOBAL_CONFIG_PATH_JSONC = join(GLOBAL_CONFIG_DIR, "rcl.jsonc");
+const GLOBAL_CONFIG_PATH_JSON = join(GLOBAL_CONFIG_DIR, "rcl.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/rcl.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/rcl.jsonc|json
+    let configDirPath = null;
+    const opencodeConfigDir = process.env.OPENCODE_CONFIG_DIR;
+    if (opencodeConfigDir) {
+        const configJsonc = join(opencodeConfigDir, "rcl.jsonc");
+        const configJson = join(opencodeConfigDir, "rcl.json");
+        if (existsSync(configJsonc)) {
+            configDirPath = configJsonc;
+        }
+        else if (existsSync(configJson)) {
+            configDirPath = configJson;
+        }
+    }
+    // Project: <project>/.opencode/rcl.jsonc|json
+    let projectPath = null;
+    if (ctx?.directory) {
+        const opencodeDir = findOpencodeDir(ctx.directory);
+        if (opencodeDir) {
+            const projectJsonc = join(opencodeDir, "rcl.jsonc");
+            const projectJson = join(opencodeDir, "rcl.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/SleepingBag945/opencode-recall/master/rcl.schema.json",
+  // Enable or disable the plugin
+  "enabled": true,
+  // Enable debug logging to ~/.config/opencode/logs/rcl/
+  "debug": false,
+  // Notification display: "off", "minimal", or "detailed"
+  "pruneNotification": "detailed",
+  // Protect from pruning for <turns> message turns
+  "turnProtection": {
+    "enabled": false,
+    "turns": 4
+  },
+  // Protect file operations from pruning via glob patterns
+  // Patterns match tool parameters.filePath (e.g. read/write/edit)
+  "protectedFilePatterns": [],
+  // Sub-agent based blob exploration (restore in a child session; return a small distilled answer)
+  "explore": {
+    "enabled": true,
+    // Optional: override the model for the rcl_explorer sub-agent.
+    // If omitted, Recall will infer a default from your OpenCode agent config.
+    // "agentModel": "openai/gpt-4o-mini",
+    // Optional: override reasoning effort for the sub-agent (if your OpenCode supports variants)
+    "agentVariant": "low",
+    // Timeout for the sub-agent session in milliseconds
+    "timeoutMs": 120000,
+    // Hard cap for how many characters rcl_explore returns to the main session
+    "maxResultChars": 4000
+  },
+  // LLM-driven context pruning tools
+  "tools": {
+    // Shared settings for all prune tools
+    "settings": {
+      // Nudge the LLM to use prune tools (every <nudgeFrequency> tool results)
+      "nudgeEnabled": true,
+      "nudgeFrequency": 10,
+      // Protect rcl_restore outputs for N turns before they can be pruned
+      "restoreProtectionTurns": 4,
+      // Block rcl_restore when content exceeds this size (bytes)
+      "restoreMaxBytes": 8000,
+      // Additional tools to protect from pruning
+      "protectedTools": []
+
+    },
+    // Removes tool content from context without preservation (for completed tasks or noise)
+    "discard": {
+      "enabled": true
+    },
+    // Distills key findings into preserved knowledge before removing raw content
+	    "extract": {
+	      "enabled": true,
+	      // Show distillation content in the toast notification
+	      "showDistillation": false
+	    }
+  },
+  // Automatic pruning strategies
+  "strategies": {
+    // Remove duplicate tool calls (same tool with same arguments)
+    "deduplication": {
+      "enabled": true,
+      // Additional tools to protect from pruning
+      "protectedTools": []
+    },
+      // Prune write tool inputs when the file has been subsequently read
+      "supersedeWrites": {
+        "enabled": true
+      },
+
+    // Prune tool inputs for errored tools after X turns
+    "purgeErrors": {
+      "enabled": true,
+      // Number of turns before errored tool inputs are pruned
+      "turns": 4,
+      // Additional tools to protect from pruning
+      "protectedTools": []
+    }
+  }
+}
+`;
+    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 ?? []),
+                ]),
+            ],
+        },
+    };
+}
+function mergeTools(base, override) {
+    if (!override)
+        return base;
+    return {
+        settings: {
+            nudgeEnabled: override.settings?.nudgeEnabled ?? base.settings.nudgeEnabled,
+            nudgeFrequency: override.settings?.nudgeFrequency ?? base.settings.nudgeFrequency,
+            restoreProtectionTurns: override.settings?.restoreProtectionTurns ?? base.settings.restoreProtectionTurns,
+            restoreMaxBytes: override.settings?.restoreMaxBytes ?? base.settings.restoreMaxBytes,
+            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 mergeExplore(base, override) {
+    if (!override)
+        return base;
+    return {
+        enabled: override.enabled ?? base.enabled,
+        agentModel: override.agentModel ?? base.agentModel,
+        agentVariant: override.agentVariant ?? base.agentVariant,
+        timeoutMs: override.timeoutMs ?? base.timeoutMs,
+        maxResultChars: override.maxResultChars ?? base.maxResultChars,
+    };
+}
+function deepCloneConfig(config) {
+    return {
+        ...config,
+        turnProtection: { ...config.turnProtection },
+        protectedFilePatterns: [...config.protectedFilePatterns],
+        explore: { ...config.explore },
+        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],
+            },
+        },
+    };
+}
+export function getConfig(ctx) {
+    let config = deepCloneConfig(defaultConfig);
+    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: "RCL: 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,
+                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 ?? []),
+                    ]),
+                ],
+                explore: mergeExplore(config.explore, result.data.explore),
+                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/rcl.jsonc|json (overrides global)
+    if (configPaths.configDir) {
+        const result = loadConfigFile(configPaths.configDir);
+        if (result.parseError) {
+            setTimeout(async () => {
+                try {
+                    ctx.client.tui.showToast({
+                        body: {
+                            title: "RCL: 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,
+                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 ?? []),
+                    ]),
+                ],
+                explore: mergeExplore(config.explore, result.data.explore),
+                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: "RCL: 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,
+                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 ?? []),
+                    ]),
+                ],
+                explore: mergeExplore(config.explore, result.data.explore),
+                tools: mergeTools(config.tools, result.data.tools),
+                strategies: mergeStrategies(config.strategies, result.data.strategies),
+            };
+        }
+    }
+    return config;
+}
+//# sourceMappingURL=config.js.map