claude-conversation-memory-mcp 0.2.5 → 0.5.0

package/.claude-memory-config.example.json

@@ -0,0 +1,8 @@
+{
+  "embedding": {
+    "provider": "ollama",
+    "model": "mxbai-embed-large",
+    "dimensions": 1024,
+    "baseUrl": "http://localhost:11434"
+  }
+}

package/.claude-memory-config.example.jsonc

@@ -0,0 +1,50 @@
+{
+  "embedding": {
+    // Provider: Choose one of "ollama" | "transformers" | "openai"
+    // - ollama: Local models via Ollama (fast, private, requires Ollama installed)
+    // - transformers: Offline models via Transformers.js (no setup, slower first run)
+    // - openai: Cloud API (best quality, requires API key, costs money)
+    "provider": "ollama",
+
+    // Model name: See available models by running `config` command
+    //
+    // Ollama models (require: ollama pull <model>):
+    //   - mxbai-embed-large       (1024 dims, recommended for quality)
+    //   - nomic-embed-text        (768 dims, fast and good quality)
+    //   - all-minilm              (384 dims, lightweight)
+    //   - snowflake-arctic-embed  (1024 dims, optimized for retrieval)
+    //
+    // Transformers models (auto-download on first use, no setup):
+    //   - Xenova/all-MiniLM-L6-v2     (384 dims, default, fastest)
+    //   - Xenova/all-mpnet-base-v2    (768 dims, better quality)
+    //   - Xenova/bge-small-en-v1.5    (384 dims, English-optimized)
+    //   - Xenova/bge-base-en-v1.5     (768 dims, English, higher quality)
+    //
+    // OpenAI models (require API key):
+    //   - text-embedding-3-small  (1536 dims, $0.020 per 1M tokens)
+    //   - text-embedding-3-large  (3072 dims, $0.130 per 1M tokens, best quality)
+    //   - text-embedding-ada-002  (1536 dims, legacy)
+    "model": "mxbai-embed-large",
+
+    // Dimensions: Optional - auto-detected based on model name if omitted
+    // Only specify if you need to override auto-detection or use a custom model
+    // Valid range: 1-10000
+    //
+    // Common dimensions by model:
+    //   mxbai-embed-large: 1024
+    //   nomic-embed-text: 768
+    //   Xenova/all-MiniLM-L6-v2: 384
+    //   text-embedding-3-small: 1536
+    //   text-embedding-3-large: 3072
+    "dimensions": 1024,
+
+    // Base URL: Only for Ollama provider
+    // Default: http://localhost:11434
+    // Change if Ollama is running on a different host/port
+    "baseUrl": "http://localhost:11434"
+
+    // API Key: Only for OpenAI provider
+    // Can also be set via OPENAI_API_KEY environment variable
+    // "apiKey": "sk-..."
+  }
+}

package/README.md

@@ -9,6 +9,7 @@ A Model Context Protocol (MCP) server that gives Claude Code long-term memory by
 - **Prevents mistakes** - Learn from past errors and avoid repeating them
 - **Links to git commits** - Connect conversations to code changes
 - **Analyzes file history** - See the complete evolution of files with context
+- **Migrates conversation history** - Keep your history when renaming or moving projects
 
 ## ⚠️ Important: Claude Code CLI Only
 
@@ -56,6 +57,12 @@ Claude Code CLI is required because it stores conversation history in `~/.claude
 npm install -g claude-conversation-memory-mcp
 ```
 
+**Discover Available Models:**
+After installation, you can see all available embedding models and their dimensions:
+- Run the CLI: `claude-conversation-memory-mcp`
+- Type: `config` to see all available models organized by provider
+- Or check the example config file: `.claude-memory-config.example.jsonc`
+
 ### Configure Claude Code CLI
 
 **MCP Configuration File Priority:**
@@ -303,6 +310,82 @@ By default, conversations about the MCP itself are excluded to prevent self-refe
 You: "Index all conversations, including MCP conversations"
 ```
 
+### Indexing Options
+
+When indexing conversations, several options control what gets stored:
+
+#### Include Thinking Blocks
+
+**Default**: `false` (thinking blocks are excluded)
+
+Thinking blocks contain Claude's internal reasoning process. They can be **very large** (3-5x more data) and are usually not needed for search.
+
+```
+# Default behavior (recommended)
+You: "Index conversations"
+# Thinking blocks are excluded
+
+# Include thinking blocks (increases database size significantly)
+You: "Index conversations with thinking blocks"
+```
+
+**When to enable**:
+- ✅ You want to search Claude's reasoning process
+- ✅ You're analyzing decision-making patterns
+- ❌ Don't enable if you just want to search visible conversation content
+
+#### Exclude MCP Conversations
+
+**Default**: `"self-only"` (excludes only conversation-memory MCP calls)
+
+Controls which MCP tool interactions are indexed:
+
+- `"self-only"` (default): Excludes messages about this conversation-memory MCP to prevent self-referential loops
+- `false`: Index all MCP tool calls from all servers
+- `"all-mcp"` or `true`: Exclude all MCP tool calls from all servers
+- `["server1", "server2"]`: Exclude specific MCP servers
+
+```
+# Default - exclude only conversation-memory MCP
+You: "Index conversations"
+
+# Include all MCP conversations (including this one)
+You: "Index conversations, include all MCP tools"
+
+# Exclude all MCP tool calls
+You: "Index conversations, exclude all MCP interactions"
+```
+
+**What gets filtered**: Only the specific **messages** that invoke MCP tools are excluded, not entire conversations. This preserves conversation context while preventing self-referential loops.
+
+#### Enable Git Integration
+
+**Default**: `true` (git commits are linked)
+
+Links git commits to conversations based on timestamps and file changes.
+
+```
+# Default behavior
+You: "Index conversations"
+# Git commits are automatically linked
+
+# Disable git integration
+You: "Index conversations without git integration"
+```
+
+#### Index Output
+
+After indexing, you'll see:
+
+```
+📁 Indexed from: /path/to/modern-folder, /path/to/legacy-folder
+💾 Database: /path/to/.claude-conversations-memory.db
+```
+
+This shows:
+- **Indexed folders**: Which conversation folders were used (including legacy if it exists)
+- **Database location**: Where your indexed data is stored
+
 ### Search with Date Filters
 
 ```
@@ -317,6 +400,126 @@ You: "Generate project documentation from our conversations"
 
 Claude will create comprehensive docs combining code analysis with conversation history.
 
+### Migrate Conversation History
+
+When you rename or move a project directory, your conversation history becomes inaccessible because Claude Code creates a new folder for the new path. Use the migration tools to recover your history:
+
+**Step 1: Discover old conversation folders**
+
+```
+You: "Discover old conversations for this project"
+```
+
+Claude will scan `~/.claude/projects/` and show you folders that match your current project, ranked by similarity score. The output includes:
+- Folder name and path
+- Original project path stored in the database
+- Number of conversations and files
+- Last activity timestamp
+- Similarity score (higher = better match)
+
+**Step 2: Migrate the history**
+
+```
+You: "Migrate conversations from /Users/name/.claude/projects/-old-project-name, old path was /Users/name/old-project, new path is /Users/name/new-project"
+```
+
+Claude will:
+- Copy all conversation JSONL files to the new location
+- Update the `project_path` in the database
+- Create automatic backups (`.claude-conversations-memory.db.bak`)
+- Preserve all original data (copy, not move)
+
+**Example workflow:**
+
+```markdown
+# You renamed your project directory
+# Old: /Users/alice/code/my-app
+# New: /Users/alice/code/my-awesome-app
+
+You: "Discover old conversations for this project"
+
+Claude: Found 1 potential old conversation folder:
+- Folder: -Users-alice-code-my-app
+- Original path: /Users/alice/code/my-app
+- Conversations: 15
+- Files: 47
+- Score: 95.3
+
+You: "Migrate from /Users/alice/.claude/projects/-Users-alice-code-my-app, old path /Users/alice/code/my-app, new path /Users/alice/code/my-awesome-app"
+
+Claude: Successfully migrated 47 conversation files.
+Now you can index and search your full history!
+```
+
+**Dry run mode:**
+
+Test the migration without making changes:
+
+```
+You: "Dry run: migrate from [source] old path [old] new path [new]"
+```
+
+This shows what would be migrated without actually copying files.
+
+### Merge Conversations from Different Projects
+
+**NEW in v0.4.0**: Combine conversation history from different projects into one folder using merge mode.
+
+**Use case**: You want to merge conversations from `/project-a/drafts/2025-01-05` into your current project `/project-b`.
+
+**Step 1: Discover the source folder**
+
+```
+You: "Discover old conversations for project path /Users/name/project-a/drafts/2025-01-05"
+```
+
+**Step 2: Merge into current project**
+
+```
+You: "Merge conversations from /Users/name/.claude/projects/-project-a-drafts-2025-01-05, old path /Users/name/project-a/drafts/2025-01-05, new path /Users/name/project-b, mode merge"
+```
+
+Claude will:
+- Copy only **new** conversation files (skip duplicates)
+- Keep target conversations when IDs collide (no data loss)
+- Merge all database entries using INSERT OR IGNORE
+- Create backup of target database before merge
+- Preserve all original source data
+
+**Example workflow:**
+
+```markdown
+# Scenario: You have conversations from different projects to combine
+
+Current project: /Users/alice/main-project (already has 20 conversations)
+Source project: /Users/alice/drafts/experiment (has 10 conversations, 3 overlap with main)
+
+You: "Discover old conversations for /Users/alice/drafts/experiment"
+
+Claude: Found 1 folder:
+- Folder: -Users-alice-drafts-experiment
+- Original path: /Users/alice/drafts/experiment
+- Conversations: 10
+- Files: 10
+
+You: "Merge from /Users/alice/.claude/projects/-Users-alice-drafts-experiment, old path /Users/alice/drafts/experiment, new path /Users/alice/main-project, mode merge"
+
+Claude: Successfully merged 7 new conversation files into /Users/alice/.claude/projects/-Users-alice-main-project
+(3 duplicate conversations were skipped to preserve target data)
+Backup created at: .claude-conversations-memory.db.bak
+
+# Result: main-project now has 27 conversations (20 original + 7 new from experiment)
+```
+
+**Key differences between migrate and merge:**
+
+| Feature | Migrate Mode (default) | Merge Mode |
+|---------|----------------------|------------|
+| Target has data | ❌ Rejected (conflict) | ✅ Allowed |
+| Duplicate IDs | Overwrites target | Skips source (keeps target) |
+| Use case | Renamed project | Combine different projects |
+| Backup location | Source folder | Target folder |
+
 ## 📚 Learn More
 
 - **[Tool Examples](docs/TOOL-EXAMPLES.md)** - 50+ natural language examples for each tool

package/dist/cli/commands.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"commands.d.ts","sourceRoot":"","sources":["../../src/cli/commands.ts"],"names":[],"mappings":"AAAA;;GAEG;AAIH,OAAO,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAwDxD;;GAEG;AACH,wBAAsB,cAAc,CAClC,KAAK,EAAE,MAAM,EACb,QAAQ,EAAE,YAAY,GACrB,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CA4JxB"}
+{"version":3,"file":"commands.d.ts","sourceRoot":"","sources":["../../src/cli/commands.ts"],"names":[],"mappings":"AAAA;;GAEG;AAIH,OAAO,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAiExD;;GAEG;AACH,wBAAsB,cAAc,CAClC,KAAK,EAAE,MAAM,EACb,QAAQ,EAAE,YAAY,GACrB,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAsKxB"}

package/dist/cli/commands.js

@@ -6,9 +6,11 @@ import Table from "cli-table3";
 import { getSQLiteManager } from "../storage/SQLiteManager.js";
 import { showHelp, showCommandHelp } from "./help.js";
 import { ConfigManager } from "../embeddings/ConfigManager.js";
+import { getModelsByProvider, getAllModels, getModelsByQuality, getRecommendedModel, modelExists } from "../embeddings/ModelRegistry.js";
 import { readFileSync } from "fs";
 import { join, dirname } from "path";
 import { fileURLToPath } from "url";
+import prompts from "prompts";
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 /**
@@ -169,6 +171,14 @@ export async function executeCommand(input, handlers) {
             return chalk.yellow("Usage: config                  (show current config)\n       config <key> <value>    (set config value)");
         }
     }
+    // Handle models
+    if (command === "models") {
+        return handleModels(args);
+    }
+    // Handle select-model (interactive)
+    if (command === "select-model" || command === "select") {
+        return await handleSelectModel();
+    }
     // Handle get
     if (command === "get") {
         if (args.length === 0) {
@@ -513,10 +523,36 @@ function handleConfigShow() {
     output += `  ${chalk.cyan("dimensions")}     Embedding dimensions (e.g., 1024)\n`;
     output += `  ${chalk.cyan("baseUrl")}        Ollama base URL (default: http://localhost:11434)\n`;
     output += `  ${chalk.cyan("apiKey")}         OpenAI API key\n\n`;
+    // Show available models by provider using ModelRegistry
+    output += chalk.bold("Known Models by Provider:\n\n");
+    // Ollama models
+    output += chalk.yellow("Ollama (local):\n");
+    const ollamaModels = getModelsByProvider("ollama");
+    for (const model of ollamaModels) {
+        const suffix = model.installation ? ` ${chalk.dim(`(${model.description})`)}` : "";
+        output += `  ${model.name.padEnd(30)} ${model.dimensions.toString().padStart(4)} dims${suffix}\n`;
+    }
+    output += "\n";
+    // Transformers models
+    output += chalk.yellow("Transformers (offline):\n");
+    const transformersModels = getModelsByProvider("transformers");
+    for (const model of transformersModels) {
+        output += `  ${model.name.padEnd(30)} ${model.dimensions.toString().padStart(4)} dims  ${chalk.dim(`(${model.description})`)}\n`;
+    }
+    output += "\n";
+    // OpenAI models
+    output += chalk.yellow("OpenAI (cloud):\n");
+    const openaiModels = getModelsByProvider("openai");
+    for (const model of openaiModels) {
+        const costSuffix = model.cost ? ` - ${model.cost}` : "";
+        output += `  ${model.name.padEnd(30)} ${model.dimensions.toString().padStart(4)} dims  ${chalk.dim(`(${model.description}${costSuffix})`)}\n`;
+    }
+    output += "\n";
     output += chalk.gray(`Config file location: ${configPath}\n`);
     if (!configExists) {
         output += chalk.yellow("Config file will be created on first 'set' command.\n");
     }
+    output += chalk.gray("See example config: .claude-memory-config.example.jsonc\n");
     return output;
 }
 /**
@@ -544,33 +580,32 @@ function handleConfigGet(key) {
  */
 function handleConfigSet(key, value) {
     try {
+        // Validate model name if setting model
+        if (key === "model") {
+            if (!modelExists(value)) {
+                let warning = chalk.yellow(`⚠️  Model '${value}' is not in the registry.\n\n`);
+                warning += chalk.gray("This might be a custom model. If so, make sure to also set the correct dimensions.\n\n");
+                warning += chalk.cyan("Known models:\n");
+                warning += chalk.gray("  Run 'models' to see all available models\n");
+                warning += chalk.gray("  Or 'models <provider>' to see provider-specific models\n\n");
+                warning += chalk.yellow("Proceeding with custom model...\n\n");
+                console.warn(warning);
+            }
+        }
         ConfigManager.setConfigValue(key, value);
         // Show confirmation with helpful info
         let output = chalk.green(`✓ Config updated: ${key} = ${value}\n\n`);
         // If setting dimensions, suggest matching models
         if (key === "dimensions") {
             const dims = parseInt(value, 10);
-            output += chalk.cyan("Models with matching dimensions:\n");
-            if (dims === 384) {
-                output += "  - Xenova/all-MiniLM-L6-v2 (transformers)\n";
-                output += "  - all-minilm (ollama)\n";
-            }
-            else if (dims === 768) {
-                output += "  - nomic-embed-text (ollama)\n";
-                output += "  - Xenova/all-mpnet-base-v2 (transformers)\n";
-            }
-            else if (dims === 1024) {
-                output += "  - mxbai-embed-large (ollama) ⭐ default\n";
-                output += "  - snowflake-arctic-embed (ollama)\n";
+            const matchingModels = getAllModels().filter(m => m.dimensions === dims);
+            if (matchingModels.length > 0) {
+                output += chalk.cyan("Models with matching dimensions:\n");
+                for (const model of matchingModels) {
+                    output += `  - ${model.name} (${model.provider})\n`;
+                }
+                output += "\n";
             }
-            else if (dims === 1536) {
-                output += "  - text-embedding-3-small (openai)\n";
-                output += "  - text-embedding-ada-002 (openai)\n";
-            }
-            else if (dims === 3072) {
-                output += "  - text-embedding-3-large (openai)\n";
-            }
-            output += "\n";
         }
         // If setting model, suggest dimensions
         if (key === "model") {
@@ -587,4 +622,209 @@ function handleConfigSet(key, value) {
         return chalk.red(`Error: ${error.message}`);
     }
 }
+/**
+ * Handle models command - List, filter, search models
+ * Usage:
+ *   models                    - List all models
+ *   models <provider>         - Filter by provider (ollama, transformers, openai)
+ *   models quality <tier>     - Filter by quality (low, medium, high, highest)
+ *   models recommend          - Show recommended models for each provider
+ */
+function handleModels(args) {
+    let output = "";
+    // No args: list all models
+    if (args.length === 0) {
+        output += chalk.bold("📚 All Available Embedding Models\n\n");
+        const allModels = getAllModels();
+        output += formatModelsTable(allModels);
+        output += "\n";
+        output += chalk.gray("💡 Tip: Use 'models <provider>' to filter by provider\n");
+        output += chalk.gray("   Or: 'models quality <tier>' to filter by quality\n");
+        output += chalk.gray("   Or: 'models recommend' to see recommendations\n");
+        return output;
+    }
+    const subcommand = args[0].toLowerCase();
+    // Filter by provider
+    if (["ollama", "transformers", "openai"].includes(subcommand)) {
+        const models = getModelsByProvider(subcommand);
+        output += chalk.bold(`📚 ${capitalize(subcommand)} Models\n\n`);
+        output += formatModelsTable(models);
+        // Show recommended model for this provider
+        const recommended = getRecommendedModel(subcommand);
+        if (recommended) {
+            output += "\n";
+            output += chalk.cyan(`⭐ Recommended: ${recommended.name} (${recommended.dimensions} dims, ${recommended.quality} quality)\n`);
+        }
+        return output;
+    }
+    // Filter by quality
+    if (subcommand === "quality") {
+        if (args.length < 2) {
+            return chalk.yellow("Usage: models quality <tier>\nTiers: low, medium, high, highest");
+        }
+        const quality = args[1].toLowerCase();
+        if (!["low", "medium", "high", "highest"].includes(quality)) {
+            return chalk.red(`Invalid quality tier: ${args[1]}\nValid tiers: low, medium, high, highest`);
+        }
+        const models = getModelsByQuality(quality);
+        output += chalk.bold(`📚 ${capitalize(quality)} Quality Models\n\n`);
+        output += formatModelsTable(models);
+        return output;
+    }
+    // Show recommended models
+    if (subcommand === "recommend" || subcommand === "recommended") {
+        output += chalk.bold("⭐ Recommended Models by Provider\n\n");
+        const providers = ["ollama", "transformers", "openai"];
+        for (const provider of providers) {
+            const recommended = getRecommendedModel(provider);
+            if (recommended) {
+                output += chalk.yellow(`${capitalize(provider)}:\n`);
+                output += `  ${chalk.green(recommended.name)} ${chalk.dim(`(${recommended.dimensions} dims, ${recommended.quality} quality)`)}\n`;
+                output += `  ${chalk.dim(recommended.description)}\n`;
+                if (recommended.installation) {
+                    output += `  ${chalk.dim(`Install: ${recommended.installation}`)}\n`;
+                }
+                if (recommended.cost) {
+                    output += `  ${chalk.dim(`Cost: ${recommended.cost}`)}\n`;
+                }
+                output += "\n";
+            }
+        }
+        return output;
+    }
+    return chalk.yellow(`Unknown models subcommand: ${subcommand}\n\nUsage:\n  models                    - List all models\n  models <provider>         - Filter by provider (ollama, transformers, openai)\n  models quality <tier>     - Filter by quality\n  models recommend          - Show recommendations`);
+}
+/**
+ * Format models into a table
+ */
+function formatModelsTable(models) {
+    const table = new Table({
+        head: [
+            chalk.cyan("Model"),
+            chalk.cyan("Provider"),
+            chalk.cyan("Dimensions"),
+            chalk.cyan("Quality"),
+            chalk.cyan("Description")
+        ],
+        colWidths: [35, 13, 12, 10, 45],
+        wordWrap: true,
+    });
+    for (const model of models) {
+        table.push([
+            model.name,
+            model.provider,
+            model.dimensions.toString(),
+            model.quality,
+            model.description
+        ]);
+    }
+    return table.toString();
+}
+/**
+ * Capitalize first letter
+ */
+function capitalize(str) {
+    return str.charAt(0).toUpperCase() + str.slice(1);
+}
+/**
+ * Handle interactive model selection
+ */
+async function handleSelectModel() {
+    try {
+        // Step 1: Choose provider
+        const providerResponse = await prompts({
+            type: "select",
+            name: "provider",
+            message: "Choose an embedding provider:",
+            choices: [
+                {
+                    title: "Ollama (Local, High Quality)",
+                    value: "ollama",
+                    description: "Run models locally with Ollama. Requires: ollama serve"
+                },
+                {
+                    title: "Transformers (Offline, No Setup)",
+                    value: "transformers",
+                    description: "Auto-download models, runs offline. No external setup needed."
+                },
+                {
+                    title: "OpenAI (Cloud, Highest Quality)",
+                    value: "openai",
+                    description: "Cloud API with best quality. Requires API key and costs money."
+                }
+            ],
+            initial: 0,
+        });
+        if (!providerResponse.provider) {
+            return chalk.yellow("Selection cancelled");
+        }
+        const provider = providerResponse.provider;
+        // Step 2: Choose model from that provider
+        const models = getModelsByProvider(provider);
+        const modelChoices = models.map(m => ({
+            title: `${m.name} (${m.dimensions} dims, ${m.quality} quality)`,
+            value: m.name,
+            description: m.description + (m.installation ? ` - ${m.installation}` : "") + (m.cost ? ` - ${m.cost}` : "")
+        }));
+        // Highlight recommended model
+        const recommended = getRecommendedModel(provider);
+        if (recommended) {
+            const recIndex = modelChoices.findIndex(c => c.value === recommended.name);
+            if (recIndex >= 0) {
+                modelChoices[recIndex].title = `⭐ ${modelChoices[recIndex].title} (recommended)`;
+            }
+        }
+        const modelResponse = await prompts({
+            type: "select",
+            name: "model",
+            message: `Choose a model from ${capitalize(provider)}:`,
+            choices: modelChoices,
+            initial: 0,
+        });
+        if (!modelResponse.model) {
+            return chalk.yellow("Selection cancelled");
+        }
+        const modelName = modelResponse.model;
+        const selectedModel = models.find(m => m.name === modelName);
+        if (!selectedModel) {
+            return chalk.red("Error: Model not found");
+        }
+        // Step 3: Confirm and save
+        const confirmResponse = await prompts({
+            type: "confirm",
+            name: "confirm",
+            message: `Set ${selectedModel.name} as your embedding model?\n  Provider: ${selectedModel.provider}\n  Dimensions: ${selectedModel.dimensions}\n  Quality: ${selectedModel.quality}`,
+            initial: true,
+        });
+        if (!confirmResponse.confirm) {
+            return chalk.yellow("Selection cancelled");
+        }
+        // Save configuration
+        ConfigManager.setConfigValue("provider", provider);
+        ConfigManager.setConfigValue("model", modelName);
+        ConfigManager.setConfigValue("dimensions", selectedModel.dimensions.toString());
+        let output = chalk.green(`✓ Configuration updated!\n\n`);
+        output += `  Provider: ${chalk.cyan(provider)}\n`;
+        output += `  Model: ${chalk.cyan(modelName)}\n`;
+        output += `  Dimensions: ${chalk.cyan(selectedModel.dimensions)}\n\n`;
+        // Add setup instructions
+        if (selectedModel.installation) {
+            output += chalk.yellow(`⚠️  Setup Required:\n`);
+            output += `  ${selectedModel.installation}\n\n`;
+        }
+        if (selectedModel.cost) {
+            output += chalk.yellow(`💰 Cost: ${selectedModel.cost}\n\n`);
+        }
+        output += chalk.dim("💡 Tip: You may need to reindex conversations for the new model:\n");
+        output += chalk.dim("   reset && index\n\n");
+        output += chalk.gray(`Config saved to: ${ConfigManager.getConfigPath()}\n`);
+        return output;
+    }
+    catch (error) {
+        if (error.message === "User force closed the prompt") {
+            return chalk.yellow("\nSelection cancelled");
+        }
+        return chalk.red(`Error: ${error.message}`);
+    }
+}
 //# sourceMappingURL=commands.js.map