claude-code-workflow 6.3.18 → 6.3.20

package/ccw/dist/tools/claude-cli-tools.js

@@ -1,150 +1,405 @@
 /**
  * Claude CLI Tools Configuration Manager
- * Manages .claude/cli-tools.json with fallback:
- * 1. Project workspace: {projectDir}/.claude/cli-tools.json (priority)
- * 2. Global: ~/.claude/cli-tools.json (fallback)
+ * Manages cli-tools.json (tools) and cli-settings.json (settings)
+ *
+ * Configuration Strategy (GLOBAL ONLY):
+ * - READ: Global → Default (no project-level configs)
+ * - CREATE/SAVE: Always in ~/.claude/ (global user-level config)
+ *
+ * Config location: ~/.claude/cli-tools.json
+ * Settings location: ~/.claude/cli-settings.json
+ *
+ * Note: Project-level configs are NOT used - all config is user-level.
  */
 import * as fs from 'fs';
 import * as path from 'path';
 import * as os from 'os';
 // ========== Default Config ==========
-const DEFAULT_CONFIG = {
-    version: '1.0.0',
+// Predefined models for each tool
+const PREDEFINED_MODELS = {
+    gemini: ['gemini-2.5-pro', 'gemini-2.5-flash', 'gemini-2.0-flash', 'gemini-1.5-pro', 'gemini-1.5-flash'],
+    qwen: ['coder-model', 'vision-model', 'qwen2.5-coder-32b'],
+    codex: ['gpt-5.2', 'gpt-4.1', 'o4-mini', 'o3'],
+    claude: ['sonnet', 'opus', 'haiku', 'claude-sonnet-4-5-20250929', 'claude-opus-4-5-20251101'],
+    opencode: [
+        'opencode/glm-4.7-free',
+        'opencode/gpt-5-nano',
+        'opencode/grok-code',
+        'opencode/minimax-m2.1-free',
+        'anthropic/claude-sonnet-4-20250514',
+        'anthropic/claude-opus-4-20250514',
+        'openai/gpt-4.1',
+        'openai/o3',
+        'google/gemini-2.5-pro',
+        'google/gemini-2.5-flash'
+    ]
+};
+const DEFAULT_TOOLS_CONFIG = {
+    version: '3.2.0',
+    models: { ...PREDEFINED_MODELS },
     tools: {
         gemini: {
             enabled: true,
-            isBuiltin: true,
-            command: 'gemini',
-            description: 'Google AI for code analysis'
+            primaryModel: 'gemini-2.5-pro',
+            secondaryModel: 'gemini-2.5-flash',
+            tags: [],
+            type: 'builtin'
         },
         qwen: {
             enabled: true,
-            isBuiltin: true,
-            command: 'qwen',
-            description: 'Alibaba AI assistant'
+            primaryModel: 'coder-model',
+            secondaryModel: 'coder-model',
+            tags: [],
+            type: 'builtin'
         },
         codex: {
             enabled: true,
-            isBuiltin: true,
-            command: 'codex',
-            description: 'OpenAI code generation'
+            primaryModel: 'gpt-5.2',
+            secondaryModel: 'gpt-5.2',
+            tags: [],
+            type: 'builtin'
         },
         claude: {
             enabled: true,
-            isBuiltin: true,
-            command: 'claude',
-            description: 'Anthropic AI assistant'
-        }
-    },
-    customEndpoints: [],
-    defaultTool: 'gemini',
-    settings: {
-        promptFormat: 'plain',
-        smartContext: {
-            enabled: false,
-            maxFiles: 10
+            primaryModel: 'sonnet',
+            secondaryModel: 'haiku',
+            tags: [],
+            type: 'builtin'
         },
-        nativeResume: true,
-        recursiveQuery: true,
-        cache: {
-            injectionMode: 'auto',
-            defaultPrefix: '',
-            defaultSuffix: ''
-        },
-        codeIndexMcp: 'codexlens' // Default to CodexLens
+        opencode: {
+            enabled: true,
+            primaryModel: 'opencode/glm-4.7-free',
+            secondaryModel: 'opencode/glm-4.7-free',
+            tags: [],
+            type: 'builtin'
+        }
     }
+    // Note: api-endpoint type tools are added dynamically via addClaudeApiEndpoint
+};
+const DEFAULT_SETTINGS_CONFIG = {
+    version: '1.0.0',
+    defaultTool: 'gemini',
+    promptFormat: 'plain',
+    smartContext: {
+        enabled: false,
+        maxFiles: 10
+    },
+    nativeResume: true,
+    recursiveQuery: true,
+    cache: {
+        injectionMode: 'auto',
+        defaultPrefix: '',
+        defaultSuffix: ''
+    },
+    codeIndexMcp: 'ace'
 };
 // ========== Helper Functions ==========
 function getProjectConfigPath(projectDir) {
     return path.join(projectDir, '.claude', 'cli-tools.json');
 }
+function getProjectSettingsPath(projectDir) {
+    return path.join(projectDir, '.claude', 'cli-settings.json');
+}
 function getGlobalConfigPath() {
     return path.join(os.homedir(), '.claude', 'cli-tools.json');
 }
+function getGlobalSettingsPath() {
+    return path.join(os.homedir(), '.claude', 'cli-settings.json');
+}
 /**
- * Resolve config path with fallback:
- * 1. Project: {projectDir}/.claude/cli-tools.json
- * 2. Global: ~/.claude/cli-tools.json
- * Returns { path, source } where source is 'project' | 'global' | 'default'
+ * Resolve config path - GLOBAL ONLY
+ * Config is user-level, stored only in ~/.claude/cli-tools.json
+ * Returns { path, source } where source is 'global' | 'default'
  */
 function resolveConfigPath(projectDir) {
-    const projectPath = getProjectConfigPath(projectDir);
-    if (fs.existsSync(projectPath)) {
-        return { path: projectPath, source: 'project' };
-    }
     const globalPath = getGlobalConfigPath();
     if (fs.existsSync(globalPath)) {
         return { path: globalPath, source: 'global' };
     }
-    return { path: projectPath, source: 'default' };
+    // Return global path for default (will be created there)
+    return { path: globalPath, source: 'default' };
 }
-function ensureClaudeDir(projectDir) {
-    const claudeDir = path.join(projectDir, '.claude');
-    if (!fs.existsSync(claudeDir)) {
-        fs.mkdirSync(claudeDir, { recursive: true });
+/**
+ * Resolve settings path - GLOBAL ONLY
+ * Settings are user-level, stored only in ~/.claude/cli-settings.json
+ */
+function resolveSettingsPath(projectDir) {
+    const globalPath = getGlobalSettingsPath();
+    if (fs.existsSync(globalPath)) {
+        return { path: globalPath, source: 'global' };
     }
+    // Return global path for default (will be created there)
+    return { path: globalPath, source: 'default' };
 }
+// NOTE: ensureClaudeDir removed - config should only be in ~/.claude/, not project directory
 // ========== Main Functions ==========
 /**
- * Load CLI tools configuration with fallback:
- * 1. Project: {projectDir}/.claude/cli-tools.json
- * 2. Global: ~/.claude/cli-tools.json
- * 3. Default config
+ * Ensure tool has required fields (for backward compatibility)
+ */
+function ensureToolTags(tool) {
+    return {
+        enabled: tool.enabled ?? true,
+        primaryModel: tool.primaryModel,
+        secondaryModel: tool.secondaryModel,
+        tags: tool.tags ?? []
+    };
+}
+/**
+ * Migrate config from older versions to v3.2.0
+ * v3.2.0: All endpoints (cli-wrapper, api-endpoint) are in tools with type field
+ */
+function migrateConfig(config, projectDir) {
+    const version = parseFloat(config.version || '1.0');
+    // Already v3.2+, no migration needed
+    if (version >= 3.2) {
+        return config;
+    }
+    console.log(`[claude-cli-tools] Migrating config from v${config.version || '1.0'} to v3.2.0`);
+    // Try to load legacy cli-config.json for model data
+    let legacyCliConfig = null;
+    try {
+        const { StoragePaths } = require('../config/storage-paths.js');
+        const legacyPath = StoragePaths.project(projectDir).cliConfig;
+        const fs = require('fs');
+        if (fs.existsSync(legacyPath)) {
+            legacyCliConfig = JSON.parse(fs.readFileSync(legacyPath, 'utf-8'));
+            console.log(`[claude-cli-tools] Found legacy cli-config.json, merging model data`);
+        }
+    }
+    catch {
+        // Ignore errors loading legacy config
+    }
+    const migratedTools = {};
+    for (const [key, tool] of Object.entries(config.tools || {})) {
+        const t = tool;
+        const legacyTool = legacyCliConfig?.tools?.[key];
+        migratedTools[key] = {
+            enabled: t.enabled ?? legacyTool?.enabled ?? true,
+            primaryModel: t.primaryModel ?? legacyTool?.primaryModel ?? DEFAULT_TOOLS_CONFIG.tools[key]?.primaryModel,
+            secondaryModel: t.secondaryModel ?? legacyTool?.secondaryModel ?? DEFAULT_TOOLS_CONFIG.tools[key]?.secondaryModel,
+            tags: t.tags ?? legacyTool?.tags ?? [],
+            type: t.type ?? DEFAULT_TOOLS_CONFIG.tools[key]?.type ?? 'builtin',
+            id: t.id // Preserve id for api-endpoint type
+        };
+    }
+    // Add any missing default tools
+    for (const [key, defaultTool] of Object.entries(DEFAULT_TOOLS_CONFIG.tools)) {
+        if (!migratedTools[key]) {
+            const legacyTool = legacyCliConfig?.tools?.[key];
+            migratedTools[key] = {
+                enabled: legacyTool?.enabled ?? defaultTool.enabled,
+                primaryModel: legacyTool?.primaryModel ?? defaultTool.primaryModel,
+                secondaryModel: legacyTool?.secondaryModel ?? defaultTool.secondaryModel,
+                tags: legacyTool?.tags ?? defaultTool.tags,
+                type: defaultTool.type ?? 'builtin'
+            };
+        }
+    }
+    // Migrate customEndpoints (v3.0 and below): cli-wrapper -> tools, others -> api-endpoint tools
+    const customEndpoints = config.customEndpoints || [];
+    for (const ep of customEndpoints) {
+        if (ep.tags?.includes('cli-wrapper')) {
+            // CLI wrapper becomes a tool with type: 'cli-wrapper'
+            if (!migratedTools[ep.name]) {
+                migratedTools[ep.name] = {
+                    enabled: ep.enabled ?? true,
+                    tags: ep.tags.filter((t) => t !== 'cli-wrapper'),
+                    type: 'cli-wrapper'
+                };
+                console.log(`[claude-cli-tools] Migrated cli-wrapper "${ep.name}" to tools`);
+            }
+        }
+        else {
+            // Pure API endpoint becomes a tool with type: 'api-endpoint'
+            if (!migratedTools[ep.name]) {
+                migratedTools[ep.name] = {
+                    enabled: ep.enabled ?? true,
+                    tags: [],
+                    type: 'api-endpoint',
+                    id: ep.id // Store endpoint ID for settings lookup
+                };
+                console.log(`[claude-cli-tools] Migrated API endpoint "${ep.name}" to tools`);
+            }
+        }
+    }
+    // Migrate apiEndpoints (v3.1): convert to tools with type: 'api-endpoint'
+    const apiEndpoints = config.apiEndpoints || [];
+    for (const ep of apiEndpoints) {
+        if (!migratedTools[ep.name]) {
+            migratedTools[ep.name] = {
+                enabled: ep.enabled ?? true,
+                tags: [],
+                type: 'api-endpoint',
+                id: ep.id // Store endpoint ID for settings lookup
+            };
+            console.log(`[claude-cli-tools] Migrated API endpoint "${ep.name}" to tools`);
+        }
+    }
+    return {
+        version: '3.2.0',
+        models: { ...PREDEFINED_MODELS },
+        tools: migratedTools,
+        $schema: config.$schema
+    };
+}
+/**
+ * Ensure CLI tools configuration file exists
+ * Creates default config in global ~/.claude directory (user-level config)
+ * @param projectDir - Project directory path (used for reading existing project config)
+ * @param createInProject - DEPRECATED: Always creates in global dir. Kept for backward compatibility.
+ * @returns The config that was created/exists
+ */
+export function ensureClaudeCliTools(projectDir, createInProject = false) {
+    const resolved = resolveConfigPath(projectDir);
+    if (resolved.source !== 'default') {
+        // Config exists, load and return it
+        return loadClaudeCliTools(projectDir);
+    }
+    // Config doesn't exist - create in global directory only
+    console.log('[claude-cli-tools] Config not found, creating default cli-tools.json in ~/.claude');
+    const defaultConfig = { ...DEFAULT_TOOLS_CONFIG };
+    // Always create in global directory (user-level config)
+    const globalDir = path.join(os.homedir(), '.claude');
+    if (!fs.existsSync(globalDir)) {
+        fs.mkdirSync(globalDir, { recursive: true });
+    }
+    const globalPath = getGlobalConfigPath();
+    try {
+        fs.writeFileSync(globalPath, JSON.stringify(defaultConfig, null, 2), 'utf-8');
+        console.log(`[claude-cli-tools] Created default config at: ${globalPath}`);
+        return { ...defaultConfig, _source: 'global' };
+    }
+    catch (err) {
+        console.error('[claude-cli-tools] Failed to create global config:', err);
+        return { ...defaultConfig, _source: 'default' };
+    }
+}
+/**
+ * Load CLI tools configuration from global ~/.claude/cli-tools.json
+ * Falls back to default config if not found.
+ *
+ * Automatically migrates older config versions to v3.2.0
  */
 export function loadClaudeCliTools(projectDir) {
     const resolved = resolveConfigPath(projectDir);
     try {
         if (resolved.source === 'default') {
-            // No config file found, return defaults
-            return { ...DEFAULT_CONFIG, _source: 'default' };
+            return { ...DEFAULT_TOOLS_CONFIG, _source: 'default' };
         }
         const content = fs.readFileSync(resolved.path, 'utf-8');
         const parsed = JSON.parse(content);
-        // Merge with defaults
+        // Migrate older versions to v3.2.0
+        const migrated = migrateConfig(parsed, projectDir);
+        const needsSave = migrated.version !== parsed.version;
+        // Merge tools with defaults and ensure required fields exist
+        const mergedTools = {};
+        for (const [key, tool] of Object.entries({ ...DEFAULT_TOOLS_CONFIG.tools, ...(migrated.tools || {}) })) {
+            mergedTools[key] = {
+                ...ensureToolTags(tool),
+                type: tool.type ?? 'builtin',
+                id: tool.id // Preserve id for api-endpoint type
+            };
+        }
         const config = {
-            ...DEFAULT_CONFIG,
-            ...parsed,
-            tools: { ...DEFAULT_CONFIG.tools, ...(parsed.tools || {}) },
-            settings: {
-                ...DEFAULT_CONFIG.settings,
-                ...(parsed.settings || {}),
-                smartContext: {
-                    ...DEFAULT_CONFIG.settings.smartContext,
-                    ...(parsed.settings?.smartContext || {})
-                },
-                cache: {
-                    ...DEFAULT_CONFIG.settings.cache,
-                    ...(parsed.settings?.cache || {})
-                }
-            },
+            version: migrated.version || DEFAULT_TOOLS_CONFIG.version,
+            models: migrated.models || DEFAULT_TOOLS_CONFIG.models,
+            tools: mergedTools,
+            $schema: migrated.$schema,
             _source: resolved.source
         };
-        console.log(`[claude-cli-tools] Loaded config from ${resolved.source}: ${resolved.path}`);
+        // Save migrated config if version changed
+        if (needsSave) {
+            try {
+                saveClaudeCliTools(projectDir, config);
+                console.log(`[claude-cli-tools] Saved migrated config to: ${resolved.path}`);
+            }
+            catch (err) {
+                console.warn('[claude-cli-tools] Failed to save migrated config:', err);
+            }
+        }
+        console.log(`[claude-cli-tools] Loaded tools config from ${resolved.source}: ${resolved.path}`);
         return config;
     }
     catch (err) {
-        console.error('[claude-cli-tools] Error loading config:', err);
-        return { ...DEFAULT_CONFIG, _source: 'default' };
+        console.error('[claude-cli-tools] Error loading tools config:', err);
+        return { ...DEFAULT_TOOLS_CONFIG, _source: 'default' };
     }
 }
 /**
- * Save CLI tools configuration to project .claude/cli-tools.json
- * Always saves to project directory (not global)
+ * Save CLI tools configuration to global ~/.claude/cli-tools.json
+ * Always saves to global directory (user-level config)
  */
 export function saveClaudeCliTools(projectDir, config) {
-    ensureClaudeDir(projectDir);
-    const configPath = getProjectConfigPath(projectDir);
-    // Remove internal _source field before saving
     const { _source, ...configToSave } = config;
+    // Always save to global directory
+    const globalDir = path.join(os.homedir(), '.claude');
+    if (!fs.existsSync(globalDir)) {
+        fs.mkdirSync(globalDir, { recursive: true });
+    }
+    const configPath = getGlobalConfigPath();
     try {
         fs.writeFileSync(configPath, JSON.stringify(configToSave, null, 2), 'utf-8');
-        console.log(`[claude-cli-tools] Saved config to project: ${configPath}`);
+        console.log(`[claude-cli-tools] Saved tools config to: ${configPath}`);
     }
     catch (err) {
-        console.error('[claude-cli-tools] Error saving config:', err);
+        console.error('[claude-cli-tools] Error saving tools config:', err);
         throw new Error(`Failed to save CLI tools config: ${err}`);
     }
 }
+/**
+ * Load CLI settings configuration from global ~/.claude/cli-settings.json
+ * Falls back to default settings if not found.
+ */
+export function loadClaudeCliSettings(projectDir) {
+    const resolved = resolveSettingsPath(projectDir);
+    try {
+        if (resolved.source === 'default') {
+            return { ...DEFAULT_SETTINGS_CONFIG, _source: 'default' };
+        }
+        const content = fs.readFileSync(resolved.path, 'utf-8');
+        const parsed = JSON.parse(content);
+        const config = {
+            ...DEFAULT_SETTINGS_CONFIG,
+            ...parsed,
+            smartContext: {
+                ...DEFAULT_SETTINGS_CONFIG.smartContext,
+                ...(parsed.smartContext || {})
+            },
+            cache: {
+                ...DEFAULT_SETTINGS_CONFIG.cache,
+                ...(parsed.cache || {})
+            },
+            _source: resolved.source
+        };
+        console.log(`[claude-cli-tools] Loaded settings from ${resolved.source}: ${resolved.path}`);
+        return config;
+    }
+    catch (err) {
+        console.error('[claude-cli-tools] Error loading settings:', err);
+        return { ...DEFAULT_SETTINGS_CONFIG, _source: 'default' };
+    }
+}
+/**
+ * Save CLI settings configuration to global ~/.claude/cli-settings.json
+ * Always saves to global directory (user-level config)
+ */
+export function saveClaudeCliSettings(projectDir, config) {
+    const { _source, ...configToSave } = config;
+    // Always save to global directory
+    const globalDir = path.join(os.homedir(), '.claude');
+    if (!fs.existsSync(globalDir)) {
+        fs.mkdirSync(globalDir, { recursive: true });
+    }
+    const settingsPath = getGlobalSettingsPath();
+    try {
+        fs.writeFileSync(settingsPath, JSON.stringify(configToSave, null, 2), 'utf-8');
+        console.log(`[claude-cli-tools] Saved settings to: ${settingsPath}`);
+    }
+    catch (err) {
+        console.error('[claude-cli-tools] Error saving settings:', err);
+        throw new Error(`Failed to save CLI settings: ${err}`);
+    }
+}
 /**
  * Update enabled status for a specific tool
  */
@@ -160,45 +415,91 @@ export function updateClaudeToolEnabled(projectDir, toolName, enabled) {
  * Update cache settings
  */
 export function updateClaudeCacheSettings(projectDir, cacheSettings) {
-    const config = loadClaudeCliTools(projectDir);
-    config.settings.cache = {
-        ...config.settings.cache,
+    const settings = loadClaudeCliSettings(projectDir);
+    settings.cache = {
+        ...settings.cache,
         ...cacheSettings
     };
-    saveClaudeCliTools(projectDir, config);
-    return config;
+    saveClaudeCliSettings(projectDir, settings);
+    return settings;
 }
 /**
  * Update default tool
  */
 export function updateClaudeDefaultTool(projectDir, defaultTool) {
+    const settings = loadClaudeCliSettings(projectDir);
+    settings.defaultTool = defaultTool;
+    saveClaudeCliSettings(projectDir, settings);
+    return settings;
+}
+/**
+ * Add API endpoint as a tool with type: 'api-endpoint'
+ * Usage: --tool <name> or --tool custom --model <id>
+ */
+export function addClaudeApiEndpoint(projectDir, endpoint) {
     const config = loadClaudeCliTools(projectDir);
-    config.defaultTool = defaultTool;
+    // Add as a tool with type: 'api-endpoint'
+    config.tools[endpoint.name] = {
+        enabled: endpoint.enabled,
+        tags: [],
+        type: 'api-endpoint',
+        id: endpoint.id // Store endpoint ID for settings lookup
+    };
     saveClaudeCliTools(projectDir, config);
     return config;
 }
 /**
- * Add custom endpoint
+ * Remove API endpoint tool by id or name
+ */
+export function removeClaudeApiEndpoint(projectDir, endpointId) {
+    const config = loadClaudeCliTools(projectDir);
+    // Find the tool by id or name
+    const toolToRemove = Object.entries(config.tools).find(([name, t]) => t.type === 'api-endpoint' && (t.id === endpointId || name === endpointId || name.toLowerCase() === endpointId.toLowerCase()));
+    if (toolToRemove) {
+        delete config.tools[toolToRemove[0]];
+    }
+    saveClaudeCliTools(projectDir, config);
+    return config;
+}
+/**
+ * @deprecated Use addClaudeApiEndpoint instead
+ * Adds tool to config based on tags:
+ * - cli-wrapper tag -> type: 'cli-wrapper'
+ * - others -> type: 'api-endpoint'
  */
 export function addClaudeCustomEndpoint(projectDir, endpoint) {
     const config = loadClaudeCliTools(projectDir);
-    // Check if endpoint already exists
-    const existingIndex = config.customEndpoints.findIndex(e => e.id === endpoint.id);
-    if (existingIndex >= 0) {
-        config.customEndpoints[existingIndex] = endpoint;
+    if (endpoint.tags?.includes('cli-wrapper')) {
+        // CLI wrapper tool
+        config.tools[endpoint.name] = {
+            enabled: endpoint.enabled,
+            tags: endpoint.tags.filter(t => t !== 'cli-wrapper'),
+            type: 'cli-wrapper'
+        };
     }
     else {
-        config.customEndpoints.push(endpoint);
+        // API endpoint tool
+        config.tools[endpoint.name] = {
+            enabled: endpoint.enabled,
+            tags: [],
+            type: 'api-endpoint',
+            id: endpoint.id
+        };
     }
     saveClaudeCliTools(projectDir, config);
     return config;
 }
 /**
- * Remove custom endpoint
+ * Remove endpoint tool (cli-wrapper or api-endpoint)
  */
 export function removeClaudeCustomEndpoint(projectDir, endpointId) {
     const config = loadClaudeCliTools(projectDir);
-    config.customEndpoints = config.customEndpoints.filter(e => e.id !== endpointId);
+    // Find the tool by id or name (cli-wrapper or api-endpoint type)
+    const toolToRemove = Object.entries(config.tools).find(([name, t]) => (t.type === 'cli-wrapper' || t.type === 'api-endpoint') &&
+        (name === endpointId || name.toLowerCase() === endpointId.toLowerCase() || t.id === endpointId));
+    if (toolToRemove) {
+        delete config.tools[toolToRemove[0]];
+    }
     saveClaudeCliTools(projectDir, config);
     return config;
 }
@@ -221,10 +522,10 @@ export function getClaudeCliToolsInfo(projectDir) {
  */
 export function updateCodeIndexMcp(projectDir, provider) {
     try {
-        // Update config
-        const config = loadClaudeCliTools(projectDir);
-        config.settings.codeIndexMcp = provider;
-        saveClaudeCliTools(projectDir, config);
+        // Update settings config
+        const settings = loadClaudeCliSettings(projectDir);
+        settings.codeIndexMcp = provider;
+        saveClaudeCliSettings(projectDir, settings);
         // Only update global CLAUDE.md (consistent with Chinese response / Windows platform)
         const globalClaudeMdPath = path.join(os.homedir(), '.claude', 'CLAUDE.md');
         // Define patterns for all formats
@@ -260,7 +561,7 @@ export function updateCodeIndexMcp(projectDir, provider) {
             fs.writeFileSync(globalClaudeMdPath, content, 'utf-8');
             console.log(`[claude-cli-tools] Updated global CLAUDE.md to use ${provider}`);
         }
-        return { success: true, config };
+        return { success: true, settings };
     }
     catch (err) {
         console.error('[claude-cli-tools] Error updating Code Index MCP:', err);
@@ -271,8 +572,8 @@ export function updateCodeIndexMcp(projectDir, provider) {
  * Get current Code Index MCP provider
  */
 export function getCodeIndexMcp(projectDir) {
-    const config = loadClaudeCliTools(projectDir);
-    return config.settings.codeIndexMcp || 'codexlens';
+    const settings = loadClaudeCliSettings(projectDir);
+    return settings.codeIndexMcp || 'ace';
 }
 /**
  * Get the context-tools file path based on provider
@@ -287,4 +588,93 @@ export function getContextToolsPath(provider) {
             return 'context-tools.md';
     }
 }
+// ========== Model Configuration Functions ==========
+/**
+ * Get predefined models for a specific tool
+ */
+export function getPredefinedModels(tool) {
+    const toolName = tool;
+    return PREDEFINED_MODELS[toolName] ? [...PREDEFINED_MODELS[toolName]] : [];
+}
+/**
+ * Get all predefined models
+ */
+export function getAllPredefinedModels() {
+    return { ...PREDEFINED_MODELS };
+}
+/**
+ * Get tool configuration (compatible with cli-config-manager interface)
+ */
+export function getToolConfig(projectDir, tool) {
+    const config = loadClaudeCliTools(projectDir);
+    const toolConfig = config.tools[tool];
+    if (!toolConfig) {
+        const defaultTool = DEFAULT_TOOLS_CONFIG.tools[tool];
+        return {
+            enabled: defaultTool?.enabled ?? true,
+            primaryModel: defaultTool?.primaryModel ?? '',
+            secondaryModel: defaultTool?.secondaryModel ?? '',
+            tags: defaultTool?.tags ?? []
+        };
+    }
+    return {
+        enabled: toolConfig.enabled,
+        primaryModel: toolConfig.primaryModel ?? '',
+        secondaryModel: toolConfig.secondaryModel ?? '',
+        tags: toolConfig.tags
+    };
+}
+/**
+ * Update tool configuration
+ */
+export function updateToolConfig(projectDir, tool, updates) {
+    const config = loadClaudeCliTools(projectDir);
+    if (config.tools[tool]) {
+        if (updates.enabled !== undefined) {
+            config.tools[tool].enabled = updates.enabled;
+        }
+        if (updates.primaryModel !== undefined) {
+            config.tools[tool].primaryModel = updates.primaryModel;
+        }
+        if (updates.secondaryModel !== undefined) {
+            config.tools[tool].secondaryModel = updates.secondaryModel;
+        }
+        if (updates.tags !== undefined) {
+            config.tools[tool].tags = updates.tags;
+        }
+        saveClaudeCliTools(projectDir, config);
+    }
+    return config;
+}
+/**
+ * Get primary model for a tool
+ */
+export function getPrimaryModel(projectDir, tool) {
+    const toolConfig = getToolConfig(projectDir, tool);
+    return toolConfig.primaryModel;
+}
+/**
+ * Get secondary model for a tool
+ */
+export function getSecondaryModel(projectDir, tool) {
+    const toolConfig = getToolConfig(projectDir, tool);
+    return toolConfig.secondaryModel;
+}
+/**
+ * Check if a tool is enabled
+ */
+export function isToolEnabled(projectDir, tool) {
+    const toolConfig = getToolConfig(projectDir, tool);
+    return toolConfig.enabled;
+}
+/**
+ * Get full config response for API (includes predefined models)
+ */
+export function getFullConfigResponse(projectDir) {
+    const config = loadClaudeCliTools(projectDir);
+    return {
+        config,
+        predefinedModels: { ...PREDEFINED_MODELS }
+    };
+}
 //# sourceMappingURL=claude-cli-tools.js.map