openrecall 0.2.2 → 0.4.0

package/src/dcp/config.ts

@@ -0,0 +1,981 @@
+import { readFileSync, writeFileSync, existsSync, mkdirSync, statSync } from "fs"
+import { join, dirname } from "path"
+import { homedir } from "os"
+import { parse } from "jsonc-parser"
+import type { PluginInput } from "@opencode-ai/plugin"
+
+export interface Deduplication {
+    enabled: boolean
+    protectedTools: string[]
+}
+
+export interface PruneTool {
+    permission: "ask" | "allow" | "deny"
+}
+
+export interface DistillTool {
+    permission: "ask" | "allow" | "deny"
+    showDistillation: boolean
+}
+
+export interface CompressTool {
+    permission: "ask" | "allow" | "deny"
+    showCompression: boolean
+}
+
+export interface ToolSettings {
+    nudgeEnabled: boolean
+    nudgeFrequency: number
+    protectedTools: string[]
+    contextLimit: number | `${number}%`
+    modelLimits?: Record<string, number | `${number}%`>
+}
+
+export interface Tools {
+    settings: ToolSettings
+    distill: DistillTool
+    compress: CompressTool
+    prune: PruneTool
+}
+
+export interface Commands {
+    enabled: boolean
+    protectedTools: string[]
+}
+
+export interface ManualModeConfig {
+    enabled: boolean
+    automaticStrategies: boolean
+}
+
+export interface SupersedeWrites {
+    enabled: boolean
+}
+
+export interface PurgeErrors {
+    enabled: boolean
+    turns: number
+    protectedTools: string[]
+}
+
+export interface TurnProtection {
+    enabled: boolean
+    turns: number
+}
+
+export interface PluginConfig {
+    enabled: boolean
+    debug: boolean
+    pruneNotification: "off" | "minimal" | "detailed"
+    pruneNotificationType: "chat" | "toast"
+    commands: Commands
+    manualMode: ManualModeConfig
+    turnProtection: TurnProtection
+    protectedFilePatterns: string[]
+    tools: Tools
+    strategies: {
+        deduplication: Deduplication
+        supersedeWrites: SupersedeWrites
+        purgeErrors: PurgeErrors
+    }
+}
+
+const DEFAULT_PROTECTED_TOOLS = [
+    "task",
+    "todowrite",
+    "todoread",
+    "distill",
+    "compress",
+    "prune",
+    "batch",
+    "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",
+    "pruneNotificationType",
+    "turnProtection",
+    "turnProtection.enabled",
+    "turnProtection.turns",
+    "protectedFilePatterns",
+    "commands",
+    "commands.enabled",
+    "commands.protectedTools",
+    "manualMode",
+    "manualMode.enabled",
+    "manualMode.automaticStrategies",
+    "tools",
+    "tools.settings",
+    "tools.settings.nudgeEnabled",
+    "tools.settings.nudgeFrequency",
+    "tools.settings.protectedTools",
+    "tools.settings.contextLimit",
+    "tools.settings.modelLimits",
+    "tools.distill",
+    "tools.distill.permission",
+    "tools.distill.showDistillation",
+    "tools.compress",
+    "tools.compress.permission",
+    "tools.compress.showCompression",
+    "tools.prune",
+    "tools.prune.permission",
+    "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: Record<string, any>, prefix = ""): string[] {
+    const keys: string[] = []
+    for (const key of Object.keys(obj)) {
+        const fullKey = prefix ? `${prefix}.${key}` : key
+        keys.push(fullKey)
+
+        // modelLimits is a dynamic map keyed by providerID/modelID; do not recurse into arbitrary IDs.
+        if (fullKey === "tools.settings.modelLimits") {
+            continue
+        }
+
+        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: Record<string, any>): string[] {
+    const userKeys = getConfigKeyPaths(userConfig)
+    return userKeys.filter((key) => !VALID_CONFIG_KEYS.has(key))
+}
+
+// Type validators for config values
+interface ValidationError {
+    key: string
+    expected: string
+    actual: string
+}
+
+export function validateConfigTypes(config: Record<string, any>): ValidationError[] {
+    const errors: ValidationError[] = []
+
+    // 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.pruneNotificationType !== undefined) {
+        const validValues = ["chat", "toast"]
+        if (!validValues.includes(config.pruneNotificationType)) {
+            errors.push({
+                key: "pruneNotificationType",
+                expected: '"chat" | "toast"',
+                actual: JSON.stringify(config.pruneNotificationType),
+            })
+        }
+    }
+
+    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,
+            })
+        }
+    }
+
+    // Manual mode validator
+    const manualMode = config.manualMode
+    if (manualMode !== undefined) {
+        if (typeof manualMode === "object") {
+            if (manualMode.enabled !== undefined && typeof manualMode.enabled !== "boolean") {
+                errors.push({
+                    key: "manualMode.enabled",
+                    expected: "boolean",
+                    actual: typeof manualMode.enabled,
+                })
+            }
+            if (
+                manualMode.automaticStrategies !== undefined &&
+                typeof manualMode.automaticStrategies !== "boolean"
+            ) {
+                errors.push({
+                    key: "manualMode.automaticStrategies",
+                    expected: "boolean",
+                    actual: typeof manualMode.automaticStrategies,
+                })
+            }
+        } else {
+            errors.push({
+                key: "manualMode",
+                expected: "{ enabled: boolean, automaticStrategies: boolean }",
+                actual: typeof manualMode,
+            })
+        }
+    }
+
+    // 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.settings.contextLimit !== undefined) {
+                const isValidNumber = typeof tools.settings.contextLimit === "number"
+                const isPercentString =
+                    typeof tools.settings.contextLimit === "string" &&
+                    tools.settings.contextLimit.endsWith("%")
+
+                if (!isValidNumber && !isPercentString) {
+                    errors.push({
+                        key: "tools.settings.contextLimit",
+                        expected: 'number | "${number}%"',
+                        actual: JSON.stringify(tools.settings.contextLimit),
+                    })
+                }
+            }
+            if (tools.settings.modelLimits !== undefined) {
+                if (
+                    typeof tools.settings.modelLimits !== "object" ||
+                    Array.isArray(tools.settings.modelLimits)
+                ) {
+                    errors.push({
+                        key: "tools.settings.modelLimits",
+                        expected: "Record<string, number | ${number}%>",
+                        actual: typeof tools.settings.modelLimits,
+                    })
+                } else {
+                    for (const [providerModelKey, limit] of Object.entries(
+                        tools.settings.modelLimits,
+                    )) {
+                        const isValidNumber = typeof limit === "number"
+                        const isPercentString =
+                            typeof limit === "string" && /^\d+(?:\.\d+)?%$/.test(limit)
+                        if (!isValidNumber && !isPercentString) {
+                            errors.push({
+                                key: `tools.settings.modelLimits.${providerModelKey}`,
+                                expected: 'number | "${number}%"',
+                                actual: JSON.stringify(limit),
+                            })
+                        }
+                    }
+                }
+            }
+            if (tools.distill) {
+                if (tools.distill.permission !== undefined) {
+                    const validValues = ["ask", "allow", "deny"]
+                    if (!validValues.includes(tools.distill.permission)) {
+                        errors.push({
+                            key: "tools.distill.permission",
+                            expected: '"ask" | "allow" | "deny"',
+                            actual: JSON.stringify(tools.distill.permission),
+                        })
+                    }
+                }
+                if (
+                    tools.distill.showDistillation !== undefined &&
+                    typeof tools.distill.showDistillation !== "boolean"
+                ) {
+                    errors.push({
+                        key: "tools.distill.showDistillation",
+                        expected: "boolean",
+                        actual: typeof tools.distill.showDistillation,
+                    })
+                }
+            }
+        }
+        if (tools.compress) {
+            if (tools.compress.permission !== undefined) {
+                const validValues = ["ask", "allow", "deny"]
+                if (!validValues.includes(tools.compress.permission)) {
+                    errors.push({
+                        key: "tools.compress.permission",
+                        expected: '"ask" | "allow" | "deny"',
+                        actual: JSON.stringify(tools.compress.permission),
+                    })
+                }
+            }
+            if (
+                tools.compress.showCompression !== undefined &&
+                typeof tools.compress.showCompression !== "boolean"
+            ) {
+                errors.push({
+                    key: "tools.compress.showCompression",
+                    expected: "boolean",
+                    actual: typeof tools.compress.showCompression,
+                })
+            }
+        }
+        if (tools.prune) {
+            if (tools.prune.permission !== undefined) {
+                const validValues = ["ask", "allow", "deny"]
+                if (!validValues.includes(tools.prune.permission)) {
+                    errors.push({
+                        key: "tools.prune.permission",
+                        expected: '"ask" | "allow" | "deny"',
+                        actual: JSON.stringify(tools.prune.permission),
+                    })
+                }
+            }
+        }
+    }
+
+    // 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: PluginInput,
+    configPath: string,
+    configData: Record<string, any>,
+    isProject: boolean,
+): void {
+    const invalidKeys = getInvalidConfigKeys(configData)
+    const typeErrors = validateConfigTypes(configData)
+
+    if (invalidKeys.length === 0 && typeErrors.length === 0) {
+        return
+    }
+
+    const configType = isProject ? "project config" : "config"
+    const messages: string[] = []
+
+    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)
+}
+
+const defaultConfig: PluginConfig = {
+    enabled: true,
+    debug: false,
+    pruneNotification: "detailed",
+    pruneNotificationType: "chat",
+    commands: {
+        enabled: true,
+        protectedTools: [...DEFAULT_PROTECTED_TOOLS],
+    },
+    manualMode: {
+        enabled: false,
+        automaticStrategies: true,
+    },
+    turnProtection: {
+        enabled: false,
+        turns: 4,
+    },
+    protectedFilePatterns: [],
+    tools: {
+        settings: {
+            nudgeEnabled: true,
+            nudgeFrequency: 10,
+            protectedTools: [...DEFAULT_PROTECTED_TOOLS],
+            contextLimit: 100000,
+        },
+        distill: {
+            permission: "allow",
+            showDistillation: false,
+        },
+        compress: {
+            permission: "deny",
+            showCompression: false,
+        },
+        prune: {
+            permission: "allow",
+        },
+    },
+    strategies: {
+        deduplication: {
+            enabled: true,
+            protectedTools: [],
+        },
+        supersedeWrites: {
+            enabled: true,
+        },
+        purgeErrors: {
+            enabled: true,
+            turns: 4,
+            protectedTools: [],
+        },
+    },
+}
+
+const GLOBAL_CONFIG_DIR = process.env.XDG_CONFIG_HOME
+    ? join(process.env.XDG_CONFIG_HOME, "opencode")
+    : 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: string): string | null {
+    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?: PluginInput): {
+    global: string | null
+    configDir: string | null
+    project: string | null
+} {
+    // Global: ~/.config/opencode/dcp.jsonc|json
+    let globalPath: string | null = 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: string | null = 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: string | null = 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(): void {
+    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")
+}
+
+interface ConfigLoadResult {
+    data: Record<string, any> | null
+    parseError?: string
+}
+
+function loadConfigFile(configPath: string): ConfigLoadResult {
+    let fileContent: string
+    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: any) {
+        return { data: null, parseError: error.message || "Failed to parse config" }
+    }
+}
+
+function mergeStrategies(
+    base: PluginConfig["strategies"],
+    override?: Partial<PluginConfig["strategies"]>,
+): PluginConfig["strategies"] {
+    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: PluginConfig["tools"],
+    override?: Partial<PluginConfig["tools"]>,
+): PluginConfig["tools"] {
+    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 ?? []),
+                ]),
+            ],
+            contextLimit: override.settings?.contextLimit ?? base.settings.contextLimit,
+            modelLimits: override.settings?.modelLimits ?? base.settings.modelLimits,
+        },
+        distill: {
+            permission: override.distill?.permission ?? base.distill.permission,
+            showDistillation: override.distill?.showDistillation ?? base.distill.showDistillation,
+        },
+        compress: {
+            permission: override.compress?.permission ?? base.compress.permission,
+            showCompression: override.compress?.showCompression ?? base.compress.showCompression,
+        },
+        prune: {
+            permission: override.prune?.permission ?? base.prune.permission,
+        },
+    }
+}
+
+function mergeCommands(
+    base: PluginConfig["commands"],
+    override?: Partial<PluginConfig["commands"]>,
+): PluginConfig["commands"] {
+    if (override === undefined) return base
+
+    return {
+        enabled: override.enabled ?? base.enabled,
+        protectedTools: [...new Set([...base.protectedTools, ...(override.protectedTools ?? [])])],
+    }
+}
+
+function mergeManualMode(
+    base: PluginConfig["manualMode"],
+    override?: Partial<PluginConfig["manualMode"]>,
+): PluginConfig["manualMode"] {
+    if (override === undefined) return base
+
+    return {
+        enabled: override.enabled ?? base.enabled,
+        automaticStrategies: override.automaticStrategies ?? base.automaticStrategies,
+    }
+}
+
+function deepCloneConfig(config: PluginConfig): PluginConfig {
+    return {
+        ...config,
+        commands: {
+            enabled: config.commands.enabled,
+            protectedTools: [...config.commands.protectedTools],
+        },
+        manualMode: {
+            enabled: config.manualMode.enabled,
+            automaticStrategies: config.manualMode.automaticStrategies,
+        },
+        turnProtection: { ...config.turnProtection },
+        protectedFilePatterns: [...config.protectedFilePatterns],
+        tools: {
+            settings: {
+                ...config.tools.settings,
+                protectedTools: [...config.tools.settings.protectedTools],
+                modelLimits: { ...config.tools.settings.modelLimits },
+            },
+            distill: { ...config.tools.distill },
+            compress: { ...config.tools.compress },
+            prune: { ...config.tools.prune },
+        },
+        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: PluginInput): PluginConfig {
+    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: "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,
+                pruneNotificationType:
+                    result.data.pruneNotificationType ?? config.pruneNotificationType,
+                commands: mergeCommands(config.commands, result.data.commands as any),
+                manualMode: mergeManualMode(config.manualMode, result.data.manualMode as any),
+                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 as any),
+                strategies: mergeStrategies(config.strategies, result.data.strategies as any),
+            }
+        }
+    } 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,
+                pruneNotificationType:
+                    result.data.pruneNotificationType ?? config.pruneNotificationType,
+                commands: mergeCommands(config.commands, result.data.commands as any),
+                manualMode: mergeManualMode(config.manualMode, result.data.manualMode as any),
+                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 as any),
+                strategies: mergeStrategies(config.strategies, result.data.strategies as any),
+            }
+        }
+    }
+
+    // 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,
+                pruneNotificationType:
+                    result.data.pruneNotificationType ?? config.pruneNotificationType,
+                commands: mergeCommands(config.commands, result.data.commands as any),
+                manualMode: mergeManualMode(config.manualMode, result.data.manualMode as any),
+                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 as any),
+                strategies: mergeStrategies(config.strategies, result.data.strategies as any),
+            }
+        }
+    }
+
+    return config
+}