@indy2kro/agentenv 0.1.0

package/dist/config/schema.js

@@ -0,0 +1,778 @@
+/**
+ * Agentenv Configuration Schema
+ * Defines the structure and validation for agentenv.toml
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import toml from 'toml';
+// Default configuration values
+export const DEFAULT_CONFIG = {
+    scope: 'project',
+    agents: {
+        claude_code: true,
+        codex_cli: true,
+        copilot: true,
+        opencode: true,
+    },
+    tools: {
+        // Tier 1 - always enabled by default
+        ripgrep: true,
+        fd: true,
+        jq: true,
+        rtk: true,
+        // Tier 2 - enabled by default
+        ast_grep: true,
+        git_delta: true,
+        gh: true,
+        difftastic: true,
+        // Tier 3 - disabled by default
+        universal_ctags: false,
+        yq: false,
+        bat: false,
+        eza: false,
+        miller: false,
+        tokei: false,
+        hyperfine: false,
+        fzf: false,
+        just: false,
+        watchexec: false,
+        direnv: false,
+    },
+    rtk: {
+        enabled: true,
+        init: {
+            claude_code: true,
+            codex_cli: true,
+            copilot: true,
+            opencode: true,
+        },
+    },
+    tier0: {
+        check_enabled: true,
+    },
+    generate: {
+        marker_start: '<!-- agentenv-managed-start -->',
+        marker_end: '<!-- agentenv-managed-end -->',
+        files: ['AGENTS.md', 'CLAUDE.md'],
+    },
+    integrations: {
+        superpowers: {
+            enabled: false,
+            source: 'github:obra/superpowers',
+            ref: 'v6.3.0',
+            agents: ['claude_code', 'codex_cli', 'copilot', 'opencode'],
+            allow_hooks: false,
+            allow_external_requests: false,
+        },
+    },
+};
+// Known agent keys for validation
+export const AGENT_KEYS = ['claude_code', 'codex_cli', 'copilot', 'opencode'];
+// Known integration keys for validation
+export const INTEGRATION_KEYS = ['superpowers'];
+// Known tool keys for validation
+export const TOOL_KEYS = [
+    'ripgrep',
+    'fd',
+    'jq',
+    'rtk',
+    'ast_grep',
+    'git_delta',
+    'universal_ctags',
+    'gh',
+    'difftastic',
+    'yq',
+    'bat',
+    'eza',
+    'miller',
+    'tokei',
+    'hyperfine',
+    'fzf',
+    'just',
+    'watchexec',
+    'direnv',
+];
+// Tool tiers for categorization
+export const TOOL_TIERS = {
+    // Tier 1 - essential
+    ripgrep: 1,
+    fd: 1,
+    jq: 1,
+    rtk: 1,
+    // Tier 2 - AI-coding value-add
+    ast_grep: 2,
+    git_delta: 2,
+    universal_ctags: 2,
+    gh: 2,
+    difftastic: 2,
+    // Tier 3 - power-user
+    yq: 3,
+    bat: 3,
+    eza: 3,
+    miller: 3,
+    tokei: 3,
+    hyperfine: 3,
+    fzf: 3,
+    just: 3,
+    watchexec: 3,
+    direnv: 3,
+};
+// Binary name mappings (TOML key -> binary name)
+export const BINARY_MAP = {
+    ripgrep: 'rg',
+    fd: 'fd',
+    jq: 'jq',
+    rtk: 'rtk',
+    ast_grep: 'sg',
+    git_delta: 'delta',
+    universal_ctags: 'ctags',
+    gh: 'gh',
+    difftastic: 'difft',
+    yq: 'yq',
+    bat: 'bat',
+    eza: 'eza',
+    miller: 'mlr',
+    tokei: 'tokei',
+    hyperfine: 'hyperfine',
+    fzf: 'fzf',
+    just: 'just',
+    watchexec: 'watchexec',
+    direnv: 'direnv',
+};
+// Tool descriptions
+export const TOOL_DESCRIPTIONS = {
+    ripgrep: 'Fast text search (use instead of grep -r)',
+    fd: 'Fast, user-friendly file finder',
+    jq: 'Lightweight and flexible command-line JSON processor',
+    rtk: 'CLI proxy that reduces LLM token consumption by 60-90%',
+    ast_grep: 'Structural/AST-based code search and rewrite',
+    git_delta: 'Syntax-highlighted git diff pager',
+    universal_ctags: 'Universal ctags for code navigation',
+    difftastic: 'Structural diff tool that understands syntax',
+    gh: 'GitHub CLI for repository operations',
+    yq: 'YAML/TOML processor (jq for YAML)',
+    bat: 'cat clone with syntax highlighting and git integration',
+    eza: 'Modern replacement for ls',
+    miller: 'CSV/TSV data processing',
+    tokei: 'Fast code statistics (LOC, etc.)',
+    hyperfine: 'Command-line benchmarking tool',
+    fzf: 'Fuzzy finder with non-interactive filter mode',
+    just: 'Command runner for project recipes',
+    watchexec: 'File watcher that runs commands on changes',
+    direnv: 'Environment variable manager',
+};
+/**
+ * Load configuration from agentenv.toml file
+ * Searches in current directory, then user config directory
+ */
+export function loadConfig(configPath) {
+    let pathToLoad = configPath;
+    if (!pathToLoad) {
+        // Try current directory
+        try {
+            if (fs.existsSync('agentenv.toml')) {
+                pathToLoad = 'agentenv.toml';
+            }
+        }
+        catch {
+            // Ignore
+        }
+        // Try user config directory
+        if (!pathToLoad) {
+            const home = process.env.HOME || process.env.USERPROFILE || '';
+            const userConfigPath = path.join(home, '.config', 'agentenv', 'agentenv.toml');
+            try {
+                if (fs.existsSync(userConfigPath)) {
+                    pathToLoad = userConfigPath;
+                }
+            }
+            catch {
+                // Ignore
+            }
+        }
+    }
+    if (!pathToLoad) {
+        return { ...DEFAULT_CONFIG };
+    }
+    try {
+        const data = fs.readFileSync(pathToLoad, 'utf-8');
+        const parsed = toml.parse(data);
+        return mergeWithDefaults(normalizeConfig(parsed));
+    }
+    catch (err) {
+        throw new Error(`Invalid agentenv configuration at ${pathToLoad}: ${err instanceof Error ? err.message : String(err)}`, { cause: err });
+    }
+}
+/**
+ * Save configuration to agentenv.toml file
+ */
+export function saveConfig(config, configPath) {
+    try {
+        fs.mkdirSync(path.dirname(configPath), { recursive: true });
+        const tomlString = configToToml(config);
+        fs.writeFileSync(configPath, tomlString);
+    }
+    catch (err) {
+        throw new Error(`Failed to save config: ${err}`, { cause: err });
+    }
+}
+/**
+ * Convert configuration object to TOML string
+ */
+export function configToToml(config) {
+    const lines = [];
+    // Scope
+    if (config.scope) {
+        lines.push(`scope = ${tomlString(config.scope)}`);
+    }
+    // Agents
+    if (config.agents) {
+        lines.push('\n[agents]');
+        if (config.agents.claude_code !== undefined)
+            lines.push(`claude_code = ${config.agents.claude_code}`);
+        if (config.agents.codex_cli !== undefined)
+            lines.push(`codex_cli = ${config.agents.codex_cli}`);
+        if (config.agents.copilot !== undefined)
+            lines.push(`copilot = ${config.agents.copilot}`);
+        if (config.agents.opencode !== undefined)
+            lines.push(`opencode = ${config.agents.opencode}`);
+    }
+    // Tools
+    if (config.tools) {
+        lines.push('\n[tools]');
+        const toolKeys = [
+            'ripgrep',
+            'fd',
+            'jq',
+            'rtk',
+            'ast_grep',
+            'git_delta',
+            'universal_ctags',
+            'gh',
+            'difftastic',
+            'yq',
+            'bat',
+            'eza',
+            'miller',
+            'tokei',
+            'hyperfine',
+            'fzf',
+            'just',
+            'watchexec',
+            'direnv',
+        ];
+        for (const key of toolKeys) {
+            if (config.tools[key] !== undefined) {
+                lines.push(`${key} = ${config.tools[key]}`);
+            }
+        }
+    }
+    // Custom tools
+    if (config.custom_tools && config.custom_tools.length > 0) {
+        for (const ct of config.custom_tools) {
+            lines.push('\n[[custom_tools]]');
+            lines.push(`name = ${tomlString(ct.name)}`);
+            lines.push(`description = ${tomlString(ct.description)}`);
+            if (ct.already_installed !== undefined)
+                lines.push(`already_installed = ${ct.already_installed}`);
+            if (ct.mise_source)
+                lines.push(`mise_source = ${tomlString(ct.mise_source)}`);
+            if (ct.version)
+                lines.push(`version = ${tomlString(ct.version)}`);
+            if (ct.path_windows)
+                lines.push(`path_windows = ${tomlString(ct.path_windows)}`);
+            if (ct.path_macos)
+                lines.push(`path_macos = ${tomlString(ct.path_macos)}`);
+            if (ct.path_linux)
+                lines.push(`path_linux = ${tomlString(ct.path_linux)}`);
+        }
+    }
+    // RTK
+    if (config.rtk) {
+        lines.push('\n[rtk]');
+        if (config.rtk.enabled !== undefined)
+            lines.push(`enabled = ${config.rtk.enabled}`);
+        if (config.rtk.init) {
+            lines.push('\n[rtk.init]');
+            if (config.rtk.init.claude_code !== undefined)
+                lines.push(`claude_code = ${config.rtk.init.claude_code}`);
+            if (config.rtk.init.codex_cli !== undefined)
+                lines.push(`codex_cli = ${config.rtk.init.codex_cli}`);
+            if (config.rtk.init.copilot !== undefined)
+                lines.push(`copilot = ${config.rtk.init.copilot}`);
+            if (config.rtk.init.opencode !== undefined)
+                lines.push(`opencode = ${config.rtk.init.opencode}`);
+        }
+    }
+    // Tier0
+    if (config.tier0) {
+        lines.push('\n[tier0]');
+        if (config.tier0.check_enabled !== undefined)
+            lines.push(`check_enabled = ${config.tier0.check_enabled}`);
+        if (config.tier0.git_bash_path)
+            lines.push(`git_bash_path = ${tomlString(config.tier0.git_bash_path)}`);
+    }
+    // Generate
+    if (config.generate) {
+        lines.push('\n[generate]');
+        if (config.generate.marker_start)
+            lines.push(`marker_start = ${tomlString(config.generate.marker_start)}`);
+        if (config.generate.marker_end)
+            lines.push(`marker_end = ${tomlString(config.generate.marker_end)}`);
+        if (config.generate.files)
+            lines.push(`files = [${config.generate.files.map(tomlString).join(', ')}]`);
+    }
+    // Integrations
+    if (config.integrations?.superpowers) {
+        const superpowers = config.integrations.superpowers;
+        lines.push('\n[integrations.superpowers]');
+        if (superpowers.enabled !== undefined)
+            lines.push(`enabled = ${superpowers.enabled}`);
+        if (superpowers.source)
+            lines.push(`source = ${tomlString(superpowers.source)}`);
+        if (superpowers.ref)
+            lines.push(`ref = ${tomlString(superpowers.ref)}`);
+        if (superpowers.scope)
+            lines.push(`scope = ${tomlString(superpowers.scope)}`);
+        if (superpowers.agents)
+            lines.push(`agents = [${superpowers.agents.map(tomlString).join(', ')}]`);
+        if (superpowers.allow_hooks !== undefined)
+            lines.push(`allow_hooks = ${superpowers.allow_hooks}`);
+        if (superpowers.allow_external_requests !== undefined)
+            lines.push(`allow_external_requests = ${superpowers.allow_external_requests}`);
+    }
+    return lines.join('\n');
+}
+function tomlString(value) {
+    return JSON.stringify(value);
+}
+/**
+ * Merge provided config with defaults (missing properties get default values)
+ */
+function mergeWithDefaults(config) {
+    const result = { ...DEFAULT_CONFIG };
+    // Merge scope
+    if (config.scope !== undefined) {
+        result.scope = config.scope;
+    }
+    // Merge agents
+    if (config.agents) {
+        result.agents = {
+            claude_code: config.agents.claude_code ?? DEFAULT_CONFIG.agents?.claude_code,
+            codex_cli: config.agents.codex_cli ?? DEFAULT_CONFIG.agents?.codex_cli,
+            copilot: config.agents.copilot ?? DEFAULT_CONFIG.agents?.copilot,
+            opencode: config.agents.opencode ?? DEFAULT_CONFIG.agents?.opencode,
+        };
+    }
+    // Merge tools
+    if (config.tools) {
+        result.tools = {
+            ripgrep: config.tools.ripgrep ?? DEFAULT_CONFIG.tools?.ripgrep,
+            fd: config.tools.fd ?? DEFAULT_CONFIG.tools?.fd,
+            jq: config.tools.jq ?? DEFAULT_CONFIG.tools?.jq,
+            rtk: config.tools.rtk ?? DEFAULT_CONFIG.tools?.rtk,
+            ast_grep: config.tools.ast_grep ?? DEFAULT_CONFIG.tools?.ast_grep,
+            git_delta: config.tools.git_delta ?? DEFAULT_CONFIG.tools?.git_delta,
+            universal_ctags: config.tools.universal_ctags ?? DEFAULT_CONFIG.tools?.universal_ctags,
+            gh: config.tools.gh ?? DEFAULT_CONFIG.tools?.gh,
+            difftastic: config.tools.difftastic ?? DEFAULT_CONFIG.tools?.difftastic,
+            yq: config.tools.yq ?? DEFAULT_CONFIG.tools?.yq,
+            bat: config.tools.bat ?? DEFAULT_CONFIG.tools?.bat,
+            eza: config.tools.eza ?? DEFAULT_CONFIG.tools?.eza,
+            miller: config.tools.miller ?? DEFAULT_CONFIG.tools?.miller,
+            tokei: config.tools.tokei ?? DEFAULT_CONFIG.tools?.tokei,
+            hyperfine: config.tools.hyperfine ?? DEFAULT_CONFIG.tools?.hyperfine,
+            fzf: config.tools.fzf ?? DEFAULT_CONFIG.tools?.fzf,
+            just: config.tools.just ?? DEFAULT_CONFIG.tools?.just,
+            watchexec: config.tools.watchexec ?? DEFAULT_CONFIG.tools?.watchexec,
+            direnv: config.tools.direnv ?? DEFAULT_CONFIG.tools?.direnv,
+        };
+    }
+    // Merge custom_tools
+    if (config.custom_tools) {
+        result.custom_tools = config.custom_tools;
+    }
+    // Merge rtk
+    if (config.rtk) {
+        result.rtk = {
+            enabled: config.rtk.enabled ?? DEFAULT_CONFIG.rtk?.enabled,
+            init: {
+                claude_code: config.rtk.init?.claude_code ?? DEFAULT_CONFIG.rtk?.init?.claude_code,
+                codex_cli: config.rtk.init?.codex_cli ?? DEFAULT_CONFIG.rtk?.init?.codex_cli,
+                copilot: config.rtk.init?.copilot ?? DEFAULT_CONFIG.rtk?.init?.copilot,
+                opencode: config.rtk.init?.opencode ?? DEFAULT_CONFIG.rtk?.init?.opencode,
+            },
+        };
+    }
+    // Merge tier0
+    if (config.tier0) {
+        result.tier0 = {
+            check_enabled: config.tier0.check_enabled ?? DEFAULT_CONFIG.tier0?.check_enabled,
+            git_bash_path: config.tier0.git_bash_path ?? DEFAULT_CONFIG.tier0?.git_bash_path,
+        };
+    }
+    // Merge generate
+    if (config.generate) {
+        result.generate = {
+            marker_start: config.generate.marker_start ?? DEFAULT_CONFIG.generate?.marker_start,
+            marker_end: config.generate.marker_end ?? DEFAULT_CONFIG.generate?.marker_end,
+            files: config.generate.files ?? DEFAULT_CONFIG.generate?.files,
+        };
+    }
+    // Merge integrations
+    if (config.integrations) {
+        result.integrations = {
+            superpowers: config.integrations.superpowers
+                ? {
+                    enabled: config.integrations.superpowers.enabled ??
+                        DEFAULT_CONFIG.integrations?.superpowers?.enabled,
+                    source: config.integrations.superpowers.source ??
+                        DEFAULT_CONFIG.integrations?.superpowers?.source,
+                    ref: config.integrations.superpowers.ref ?? DEFAULT_CONFIG.integrations?.superpowers?.ref,
+                    scope: config.integrations.superpowers.scope ??
+                        DEFAULT_CONFIG.integrations?.superpowers?.scope,
+                    agents: config.integrations.superpowers.agents ??
+                        DEFAULT_CONFIG.integrations?.superpowers?.agents,
+                    allow_hooks: config.integrations.superpowers.allow_hooks ??
+                        DEFAULT_CONFIG.integrations?.superpowers?.allow_hooks,
+                    allow_external_requests: config.integrations.superpowers.allow_external_requests ??
+                        DEFAULT_CONFIG.integrations?.superpowers?.allow_external_requests,
+                }
+                : DEFAULT_CONFIG.integrations?.superpowers,
+        };
+    }
+    // Merge advanced
+    if (config.advanced) {
+        result.advanced = {
+            default_mode: config.advanced.default_mode ?? DEFAULT_CONFIG.advanced?.default_mode,
+            show_diff_preview: config.advanced.show_diff_preview ?? DEFAULT_CONFIG.advanced?.show_diff_preview,
+        };
+    }
+    return result;
+}
+/**
+ * Get enabled agents from config
+ */
+export function getEnabledAgents(config) {
+    const agents = config.agents || DEFAULT_CONFIG.agents || {};
+    const enabled = [];
+    if (agents.claude_code)
+        enabled.push('claude_code');
+    if (agents.codex_cli)
+        enabled.push('codex_cli');
+    if (agents.copilot)
+        enabled.push('copilot');
+    if (agents.opencode)
+        enabled.push('opencode');
+    return enabled;
+}
+/**
+ * Normalize a config parsed from TOML into the canonical schema shape.
+ * Accepts the dotted `path.windows` / `version.windows` forms used in the
+ * docs example (§6.3) and flattens them to the `path_windows` keys the rest
+ * of the pipeline expects.
+ */
+function normalizeConfig(config) {
+    if (!Array.isArray(config.custom_tools)) {
+        return config;
+    }
+    const normalized = {
+        ...config,
+        custom_tools: config.custom_tools.map((ct) => {
+            const result = { ...ct };
+            const paths = ct.path;
+            if (paths && typeof paths === 'object') {
+                if (paths.windows)
+                    result.path_windows = paths.windows;
+                if (paths.macos)
+                    result.path_macos = paths.macos;
+                if (paths.linux)
+                    result.path_linux = paths.linux;
+            }
+            const versions = ct.version;
+            if (versions && typeof versions === 'object' && !Array.isArray(versions)) {
+                result.version = versions[process.platform];
+            }
+            return result;
+        }),
+    };
+    return normalized;
+}
+/**
+ * Validate a config and report problems, separating hard errors from warnings.
+ * The CLI refuses to proceed when there are errors; warnings are surfaced but
+ * non-fatal (e.g. a catalog tool that mise cannot install from its registry).
+ */
+export function validateConfig(config) {
+    const errors = [];
+    const warnings = [];
+    if (config.scope !== undefined && config.scope !== 'project' && config.scope !== 'user') {
+        errors.push(`scope must be "project" or "user", got "${String(config.scope)}"`);
+    }
+    const agents = config.agents ?? {};
+    for (const key of Object.keys(agents)) {
+        if (!AGENT_KEYS.includes(key)) {
+            errors.push(`Unknown agent "${key}"`);
+        }
+    }
+    const tools = (config.tools ?? {});
+    for (const key of Object.keys(tools)) {
+        if (!TOOL_KEYS.includes(key)) {
+            errors.push(`Unknown tool "${key}"`);
+        }
+    }
+    if (Array.isArray(config.custom_tools)) {
+        for (const ct of config.custom_tools) {
+            if (!ct.name) {
+                errors.push('A custom tool entry is missing its "name"');
+            }
+            else if (ct.already_installed && !ct.path_windows && !ct.path_macos && !ct.path_linux) {
+                warnings.push(`custom tool "${ct.name}" is marked already_installed but has no OS path set`);
+            }
+        }
+    }
+    // Tools Phase 0 flagged as not resolvable from the mise registry.
+    const registryGapNote = {
+        universal_ctags: 'not in the mise registry; add a custom_tools fallback',
+        tokei: 'not in the mise registry; add a custom_tools fallback or local toolchain',
+    };
+    for (const [tool, note] of Object.entries(registryGapNote)) {
+        if (tools[tool]) {
+            warnings.push(`${tool}: ${note}`);
+        }
+    }
+    const integrations = (config.integrations ?? {});
+    for (const key of Object.keys(integrations)) {
+        if (!INTEGRATION_KEYS.includes(key)) {
+            errors.push(`Unknown integration "${key}"`);
+        }
+    }
+    const superpowers = config.integrations?.superpowers;
+    if (superpowers) {
+        if (superpowers.scope !== undefined &&
+            superpowers.scope !== 'project' &&
+            superpowers.scope !== 'user') {
+            errors.push(`integrations.superpowers.scope must be "project" or "user", got "${String(superpowers.scope)}"`);
+        }
+        if (superpowers.agents) {
+            for (const agent of superpowers.agents) {
+                if (!AGENT_KEYS.includes(agent)) {
+                    errors.push(`integrations.superpowers.agents contains unknown agent "${agent}"`);
+                }
+            }
+        }
+        if (superpowers.source !== undefined && superpowers.source.trim() === '') {
+            errors.push('integrations.superpowers.source must not be empty');
+        }
+        if (superpowers.ref !== undefined) {
+            if (superpowers.ref.trim() === '') {
+                errors.push('integrations.superpowers.ref must not be empty');
+            }
+            else if (!/^[A-Za-z0-9._/-]+$/.test(superpowers.ref)) {
+                errors.push(`integrations.superpowers.ref "${superpowers.ref}" contains characters that are not valid in a git ref`);
+            }
+            else if (['main', 'master', 'HEAD'].includes(superpowers.ref)) {
+                warnings.push(`integrations.superpowers.ref "${superpowers.ref}" is a floating branch; pin to a tag or commit for reproducibility`);
+            }
+        }
+    }
+    return { errors, warnings };
+}
+/**
+ * Structurally diff two configs for the pre-write review in `agentenv
+ * configure` and for drift reporting in `agentenv status` (§6.5).
+ * Tools/agents flip toggles as added/removed; scalar settings as changed.
+ */
+export function diffConfigs(oldConfig, newConfig) {
+    const entries = [];
+    const oldAgents = oldConfig.agents ?? {};
+    const newAgents = newConfig.agents ?? {};
+    const oldTools = (oldConfig.tools ?? {});
+    const newTools = (newConfig.tools ?? {});
+    if (oldConfig.scope !== newConfig.scope) {
+        entries.push({
+            kind: 'changed',
+            key: 'scope',
+            oldValue: oldConfig.scope,
+            newValue: newConfig.scope,
+        });
+    }
+    for (const key of AGENT_KEYS) {
+        const oldValue = oldAgents[key] === true;
+        const newValue = newAgents[key] === true;
+        if (oldValue !== newValue) {
+            entries.push({
+                kind: newValue ? 'added' : 'removed',
+                key: `agents.${key}`,
+                oldValue: oldValue,
+                newValue: newValue,
+            });
+        }
+    }
+    for (const key of TOOL_KEYS) {
+        const oldValue = oldTools[key] === true;
+        const newValue = newTools[key] === true;
+        if (oldValue !== newValue) {
+            entries.push({
+                kind: newValue ? 'added' : 'removed',
+                key: `tools.${key}`,
+                oldValue: oldValue,
+                newValue: newValue,
+            });
+        }
+    }
+    diffCustomTools(oldConfig.custom_tools ?? [], newConfig.custom_tools ?? [], entries);
+    diffNestedSettings([
+        ['rtk.enabled', oldConfig.rtk?.enabled, newConfig.rtk?.enabled],
+        ['rtk.init.claude_code', oldConfig.rtk?.init?.claude_code, newConfig.rtk?.init?.claude_code],
+        ['rtk.init.codex_cli', oldConfig.rtk?.init?.codex_cli, newConfig.rtk?.init?.codex_cli],
+        ['rtk.init.copilot', oldConfig.rtk?.init?.copilot, newConfig.rtk?.init?.copilot],
+        ['rtk.init.opencode', oldConfig.rtk?.init?.opencode, newConfig.rtk?.init?.opencode],
+        ['tier0.check_enabled', oldConfig.tier0?.check_enabled, newConfig.tier0?.check_enabled],
+        ['tier0.git_bash_path', oldConfig.tier0?.git_bash_path, newConfig.tier0?.git_bash_path],
+        ['generate.marker_start', oldConfig.generate?.marker_start, newConfig.generate?.marker_start],
+        ['generate.marker_end', oldConfig.generate?.marker_end, newConfig.generate?.marker_end],
+        ['generate.files', jsonOr(oldConfig.generate?.files), jsonOr(newConfig.generate?.files)],
+        ['advanced.default_mode', oldConfig.advanced?.default_mode, newConfig.advanced?.default_mode],
+        [
+            'advanced.show_diff_preview',
+            oldConfig.advanced?.show_diff_preview,
+            newConfig.advanced?.show_diff_preview,
+        ],
+        [
+            'integrations.superpowers.enabled',
+            oldConfig.integrations?.superpowers?.enabled,
+            newConfig.integrations?.superpowers?.enabled,
+        ],
+        [
+            'integrations.superpowers.source',
+            oldConfig.integrations?.superpowers?.source,
+            newConfig.integrations?.superpowers?.source,
+        ],
+        [
+            'integrations.superpowers.ref',
+            oldConfig.integrations?.superpowers?.ref,
+            newConfig.integrations?.superpowers?.ref,
+        ],
+        [
+            'integrations.superpowers.scope',
+            oldConfig.integrations?.superpowers?.scope,
+            newConfig.integrations?.superpowers?.scope,
+        ],
+        [
+            'integrations.superpowers.agents',
+            jsonOr(oldConfig.integrations?.superpowers?.agents),
+            jsonOr(newConfig.integrations?.superpowers?.agents),
+        ],
+        [
+            'integrations.superpowers.allow_hooks',
+            oldConfig.integrations?.superpowers?.allow_hooks,
+            newConfig.integrations?.superpowers?.allow_hooks,
+        ],
+        [
+            'integrations.superpowers.allow_external_requests',
+            oldConfig.integrations?.superpowers?.allow_external_requests,
+            newConfig.integrations?.superpowers?.allow_external_requests,
+        ],
+    ], entries);
+    return entries;
+}
+function diffCustomTools(oldTools, newTools, entries) {
+    const byName = (tools) => new Map(tools.map((tool) => [tool.name, tool]));
+    const oldByName = byName(oldTools);
+    const newByName = byName(newTools);
+    for (const [name, oldTool] of oldByName) {
+        if (!newByName.has(name)) {
+            entries.push({ kind: 'removed', key: `custom_tools.${name}`, oldValue: oldTool });
+        }
+    }
+    for (const [name, newTool] of newByName) {
+        if (!oldByName.has(name)) {
+            entries.push({ kind: 'added', key: `custom_tools.${name}`, newValue: newTool });
+        }
+    }
+    for (const [name, oldTool] of oldByName) {
+        if (!newByName.has(name))
+            continue;
+        const newTool = newByName.get(name);
+        const fields = [
+            ['description', oldTool.description, newTool.description],
+            ['already_installed', oldTool.already_installed, newTool.already_installed],
+            ['mise_source', oldTool.mise_source, newTool.mise_source],
+            ['version', oldTool.version, newTool.version],
+            ['path_windows', oldTool.path_windows, newTool.path_windows],
+            ['path_macos', oldTool.path_macos, newTool.path_macos],
+            ['path_linux', oldTool.path_linux, newTool.path_linux],
+        ];
+        for (const [field, oldValue, newValue] of fields) {
+            if (oldValue !== newValue) {
+                entries.push({
+                    kind: 'changed',
+                    key: `custom_tools.${name}.${field}`,
+                    oldValue,
+                    newValue,
+                });
+            }
+        }
+    }
+}
+function jsonOr(value) {
+    return value === undefined ? undefined : JSON.stringify(value);
+}
+function diffNestedSettings(pairs, entries) {
+    for (const [key, oldValue, newValue] of pairs) {
+        if (oldValue !== newValue) {
+            entries.push({ kind: 'changed', key, oldValue, newValue });
+        }
+    }
+}
+/**
+ * Get enabled tools from config
+ */
+export function getEnabledTools(config) {
+    const tools = config.tools || DEFAULT_CONFIG.tools || {};
+    const enabled = [];
+    const toolKeys = [
+        'ripgrep',
+        'fd',
+        'jq',
+        'rtk',
+        'ast_grep',
+        'git_delta',
+        'universal_ctags',
+        'gh',
+        'difftastic',
+        'yq',
+        'bat',
+        'eza',
+        'miller',
+        'tokei',
+        'hyperfine',
+        'fzf',
+        'just',
+        'watchexec',
+        'direnv',
+    ];
+    for (const key of toolKeys) {
+        if (tools[key]) {
+            enabled.push(key);
+        }
+    }
+    // Add custom tools
+    if (config.custom_tools) {
+        for (const ct of config.custom_tools) {
+            if (ct.already_installed || ct.mise_source) {
+                enabled.push(ct.name);
+            }
+        }
+    }
+    return enabled;
+}
+/**
+ * Resolve the effective scope for an integration: its own `scope` field when
+ * set, otherwise the agentenv-level scope, defaulting to "project".
+ */
+export function resolveIntegrationScope(config, integration) {
+    return integration?.scope ?? config.scope ?? 'project';
+}
+//# sourceMappingURL=schema.js.map