@wonderwhy-er/desktop-commander 0.2.10 → 0.2.12

package/dist/server.js

@@ -8,16 +8,18 @@ const OS_GUIDANCE = getOSSpecificGuidance(SYSTEM_INFO);
 const DEV_TOOL_GUIDANCE = getDevelopmentToolGuidance(SYSTEM_INFO);
 const PATH_GUIDANCE = `IMPORTANT: ${getPathGuidance(SYSTEM_INFO)} Relative paths may fail as they depend on the current working directory. Tilde paths (~/...) might not work in all contexts. Unless the user explicitly asks for relative paths, use absolute paths.`;
 const CMD_PREFIX_DESCRIPTION = `This command can be referenced as "DC: ..." or "use Desktop Commander to ..." in your instructions.`;
-import { StartProcessArgsSchema, ReadProcessOutputArgsSchema, InteractWithProcessArgsSchema, ForceTerminateArgsSchema, ListSessionsArgsSchema, KillProcessArgsSchema, ReadFileArgsSchema, ReadMultipleFilesArgsSchema, WriteFileArgsSchema, CreateDirectoryArgsSchema, ListDirectoryArgsSchema, MoveFileArgsSchema, SearchFilesArgsSchema, GetFileInfoArgsSchema, SearchCodeArgsSchema, GetConfigArgsSchema, SetConfigValueArgsSchema, ListProcessesArgsSchema, EditBlockArgsSchema, GetUsageStatsArgsSchema, GiveFeedbackArgsSchema, } from './tools/schemas.js';
+import { StartProcessArgsSchema, ReadProcessOutputArgsSchema, InteractWithProcessArgsSchema, ForceTerminateArgsSchema, ListSessionsArgsSchema, KillProcessArgsSchema, ReadFileArgsSchema, ReadMultipleFilesArgsSchema, WriteFileArgsSchema, CreateDirectoryArgsSchema, ListDirectoryArgsSchema, MoveFileArgsSchema, GetFileInfoArgsSchema, GetConfigArgsSchema, SetConfigValueArgsSchema, ListProcessesArgsSchema, EditBlockArgsSchema, GetUsageStatsArgsSchema, GiveFeedbackArgsSchema, StartSearchArgsSchema, GetMoreSearchResultsArgsSchema, StopSearchArgsSchema, ListSearchesArgsSchema, GetPromptsArgsSchema, } from './tools/schemas.js';
 import { getConfig, setConfigValue } from './tools/config.js';
 import { getUsageStats } from './tools/usage.js';
 import { giveFeedbackToDesktopCommander } from './tools/feedback.js';
+import { getPrompts } from './tools/prompts.js';
 import { trackToolCall } from './utils/trackTools.js';
 import { usageTracker } from './utils/usageTracker.js';
 import { processDockerPrompt } from './utils/dockerPrompt.js';
 import { VERSION } from './version.js';
 import { capture, capture_call_tool } from "./utils/capture.js";
-console.error("Loading server.ts");
+import { logToStderr } from './utils/logger.js';
+logToStderr('info', 'Loading server.ts');
 export const server = new Server({
     name: "desktop-commander",
     version: VERSION,
@@ -55,7 +57,8 @@ server.setRequestHandler(InitializeRequestSchema, async (request) => {
                 name: clientInfo.name || 'unknown',
                 version: clientInfo.version || 'unknown'
             };
-            console.log(`Client connected: ${currentClient.name} v${currentClient.version}`);
+            // Send JSON-RPC notification about client connection
+            logToStderr('info', `Client connected: ${currentClient.name} v${currentClient.version}`);
         }
         // Return standard initialization response
         return {
@@ -73,16 +76,16 @@ server.setRequestHandler(InitializeRequestSchema, async (request) => {
         };
     }
     catch (error) {
-        console.error("Error in initialization handler:", error);
+        logToStderr('error', `Error in initialization handler: ${error}`);
         throw error;
     }
 });
 // Export current client info for access by other modules
 export { currentClient };
-console.error("Setting up request handlers...");
+logToStderr('info', 'Setting up request handlers...');
 server.setRequestHandler(ListToolsRequestSchema, async () => {
     try {
-        console.error("Generating tools list...");
+        logToStderr('debug', 'Generating tools list...');
         return {
             tools: [
                 // Configuration tools
@@ -250,35 +253,92 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
                     inputSchema: zodToJsonSchema(MoveFileArgsSchema),
                 },
                 {
-                    name: "search_files",
+                    name: "start_search",
                     description: `
-                        Finds files by name using a case-insensitive substring matching.
+                        Start a streaming search that can return results progressively.
+                        
+                        SEARCH TYPES:
+                        - searchType="files": Find files by name (pattern matches file names)
+                        - searchType="content": Search inside files for text patterns
+                        
+                        IMPORTANT PARAMETERS:
+                        - pattern: What to search for (file names OR content text)
+                        - filePattern: Optional filter to limit search to specific file types (e.g., "*.js", "package.json")
+                        - ignoreCase: Case-insensitive search (default: true). Works for both file names and content.
+                        - earlyTermination: Stop search early when exact filename match is found (optional: defaults to true for file searches, false for content searches)
+                        
+                        EXAMPLES:
+                        - Find package.json files: searchType="files", pattern="package.json", filePattern="package.json"
+                        - Find all JS files: searchType="files", pattern="*.js" (or use filePattern="*.js")
+                        - Search for "TODO" in code: searchType="content", pattern="TODO", filePattern="*.js|*.ts"
+                        - Case-sensitive file search: searchType="files", pattern="README", ignoreCase=false
+                        - Case-insensitive file search: searchType="files", pattern="readme", ignoreCase=true
+                        - Find exact file, stop after first match: searchType="files", pattern="config.json", earlyTermination=true
+                        - Find all matching files: searchType="files", pattern="test.js", earlyTermination=false
+                        
+                        Unlike regular search tools, this starts a background search process and returns
+                        immediately with a session ID. Use get_more_search_results to get results as they
+                        come in, and stop_search to stop the search early if needed.
+                        
+                        Perfect for large directories where you want to see results immediately and
+                        have the option to cancel if the search takes too long or you find what you need.
                         
-                        Use this instead of 'execute_command' with find/dir/ls for locating files.
-                        Searches through all subdirectories from the starting path.
+                        ${PATH_GUIDANCE}
+                        ${CMD_PREFIX_DESCRIPTION}`,
+                    inputSchema: zodToJsonSchema(StartSearchArgsSchema),
+                },
+                {
+                    name: "get_more_search_results",
+                    description: `
+                        Get more results from an active search with offset-based pagination.
                         
-                        Has a default timeout of 30 seconds which can be customized using the timeoutMs parameter.
-                        Only searches within allowed directories.
+                        Supports partial result reading with:
+                        - 'offset' (start result index, default: 0)
+                          * Positive: Start from result N (0-based indexing)
+                          * Negative: Read last N results from end (tail behavior)
+                        - 'length' (max results to read, default: 100)
+                          * Used with positive offsets for range reading
+                          * Ignored when offset is negative (reads all requested tail results)
+                        
+                        Examples:
+                        - offset: 0, length: 100     → First 100 results
+                        - offset: 200, length: 50    → Results 200-249
+                        - offset: -20                → Last 20 results
+                        - offset: -5, length: 10     → Last 5 results (length ignored)
+                        
+                        Returns only results in the specified range, along with search status.
+                        Works like read_process_output - call this repeatedly to get progressive
+                        results from a search started with start_search.
                         
-                        ${PATH_GUIDANCE}
                         ${CMD_PREFIX_DESCRIPTION}`,
-                    inputSchema: zodToJsonSchema(SearchFilesArgsSchema),
+                    inputSchema: zodToJsonSchema(GetMoreSearchResultsArgsSchema),
                 },
                 {
-                    name: "search_code",
+                    name: "stop_search",
                     description: `
-                        Search for text/code patterns within file contents using ripgrep.
+                        Stop an active search.
                         
-                        Use this instead of 'execute_command' with grep/find for searching code content.
-                        Fast and powerful search similar to VS Code search functionality.
+                        Stops the background search process gracefully. Use this when you've found
+                        what you need or if a search is taking too long. Similar to force_terminate
+                        for terminal processes.
                         
-                        Supports regular expressions, file pattern filtering, and context lines.
-                        Has a default timeout of 30 seconds which can be customized.
-                        Only searches within allowed directories.
+                        The search will still be available for reading final results until it's
+                        automatically cleaned up after 5 minutes.
+                        
+                        ${CMD_PREFIX_DESCRIPTION}`,
+                    inputSchema: zodToJsonSchema(StopSearchArgsSchema),
+                },
+                {
+                    name: "list_searches",
+                    description: `
+                        List all active searches.
+                        
+                        Shows search IDs, search types, patterns, status, and runtime.
+                        Similar to list_sessions for terminal processes. Useful for managing
+                        multiple concurrent searches.
                         
-                        ${PATH_GUIDANCE}
                         ${CMD_PREFIX_DESCRIPTION}`,
-                    inputSchema: zodToJsonSchema(SearchCodeArgsSchema),
+                    inputSchema: zodToJsonSchema(ListSearchesArgsSchema),
                 },
                 {
                     name: "get_file_info",
@@ -566,11 +626,41 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
                         ${CMD_PREFIX_DESCRIPTION}`,
                     inputSchema: zodToJsonSchema(GiveFeedbackArgsSchema),
                 },
+                {
+                    name: "get_prompts",
+                    description: `
+                        Browse and retrieve curated Desktop Commander prompts for various tasks and workflows.
+                        
+                        IMPORTANT: When displaying prompt lists to users, do NOT show the internal prompt IDs (like 'onb_001'). 
+                        These IDs are for your reference only. Show users only the prompt titles and descriptions.
+                        The IDs will be provided in the response metadata for your use.
+                        
+                        ACTIONS:
+                        - list_categories: Show all available prompt categories
+                        - list_prompts: List prompts (optionally filtered by category)  
+                        - get_prompt: Retrieve and execute a specific prompt by ID
+                        
+                        WORKFLOW:
+                        1. Use list_categories to see available categories
+                        2. Use list_prompts to browse prompts in a category
+                        3. Use get_prompt with promptId to retrieve and start using a prompt
+                        
+                        EXAMPLES:
+                        - get_prompts(action='list_categories') - See all categories
+                        - get_prompts(action='list_prompts', category='onboarding') - See onboarding prompts
+                        - get_prompts(action='get_prompt', promptId='onb_001') - Get a specific prompt
+                        
+                        The get_prompt action will automatically inject the prompt content and begin execution.
+                        Perfect for discovering proven workflows and getting started with Desktop Commander.
+                        
+                        ${CMD_PREFIX_DESCRIPTION}`,
+                    inputSchema: zodToJsonSchema(GetPromptsArgsSchema),
+                },
             ],
         };
     }
     catch (error) {
-        console.error("Error in list_tools request handler:", error);
+        logToStderr('error', `Error in list_tools request handler: ${error}`);
         throw error;
     }
 });
@@ -578,9 +668,12 @@ import * as handlers from './handlers/index.js';
 server.setRequestHandler(CallToolRequestSchema, async (request) => {
     const { name, arguments: args } = request.params;
     try {
-        capture_call_tool('server_call_tool', {
-            name
-        });
+        // Prepare telemetry data - add config key for set_config_value
+        const telemetryData = { name };
+        if (name === 'set_config_value' && args && typeof args === 'object' && 'key' in args) {
+            telemetryData.set_config_value_key_name = args.key;
+        }
+        capture_call_tool('server_call_tool', telemetryData);
         // Track tool call
         trackToolCall(name, args);
         // Using a more structured approach with dedicated handlers
@@ -623,6 +716,18 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                     };
                 }
                 break;
+            case "get_prompts":
+                try {
+                    result = await getPrompts(args || {});
+                }
+                catch (error) {
+                    capture('server_request_error', { message: `Error in get_prompts handler: ${error}` });
+                    result = {
+                        content: [{ type: "text", text: `Error: Failed to retrieve prompts` }],
+                        isError: true,
+                    };
+                }
+                break;
             case "give_feedback_to_desktop_commander":
                 try {
                     result = await giveFeedbackToDesktopCommander(args);
@@ -678,11 +783,17 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             case "move_file":
                 result = await handlers.handleMoveFile(args);
                 break;
-            case "search_files":
-                result = await handlers.handleSearchFiles(args);
+            case "start_search":
+                result = await handlers.handleStartSearch(args);
+                break;
+            case "get_more_search_results":
+                result = await handlers.handleGetMoreSearchResults(args);
+                break;
+            case "stop_search":
+                result = await handlers.handleStopSearch(args);
                 break;
-            case "search_code":
-                result = await handlers.handleSearchCode(args);
+            case "list_searches":
+                result = await handlers.handleListSearches();
                 break;
             case "get_file_info":
                 result = await handlers.handleGetFileInfo(args);

package/dist/tools/filesystem.js

@@ -768,6 +768,63 @@ export async function moveFile(sourcePath, destinationPath) {
     await fs.rename(validSourcePath, validDestPath);
 }
 export async function searchFiles(rootPath, pattern) {
+    // Use the new search manager for better performance
+    // This provides a temporary compatibility layer until we fully migrate to search sessions
+    const { searchManager } = await import('../search-manager.js');
+    try {
+        const result = await searchManager.startSearch({
+            rootPath,
+            pattern,
+            searchType: 'files',
+            ignoreCase: true,
+            maxResults: 5000, // Higher limit for compatibility
+            earlyTermination: true, // Use early termination for better performance
+        });
+        const sessionId = result.sessionId;
+        // Poll for results until complete
+        let allResults = [];
+        let isComplete = result.isComplete;
+        let startTime = Date.now();
+        // Add initial results
+        for (const searchResult of result.results) {
+            if (searchResult.type === 'file') {
+                allResults.push(searchResult.file);
+            }
+        }
+        while (!isComplete) {
+            await new Promise(resolve => setTimeout(resolve, 100)); // Wait 100ms
+            const results = searchManager.readSearchResults(sessionId);
+            isComplete = results.isComplete;
+            // Add new file paths to results
+            for (const searchResult of results.results) {
+                if (searchResult.file !== '__LAST_READ_MARKER__' && searchResult.type === 'file') {
+                    allResults.push(searchResult.file);
+                }
+            }
+            // Safety check to prevent infinite loops (30 second timeout)
+            if (Date.now() - startTime > 30000) {
+                searchManager.terminateSearch(sessionId);
+                break;
+            }
+        }
+        // Log only the count of found files, not their paths
+        capture('server_search_files_complete', {
+            resultsCount: allResults.length,
+            patternLength: pattern.length,
+            usedRipgrep: true
+        });
+        return allResults;
+    }
+    catch (error) {
+        // Fallback to original Node.js implementation if ripgrep fails
+        capture('server_search_files_ripgrep_fallback', {
+            error: error instanceof Error ? error.message : 'Unknown error'
+        });
+        return await searchFilesNodeJS(rootPath, pattern);
+    }
+}
+// Keep the original Node.js implementation as fallback
+async function searchFilesNodeJS(rootPath, pattern) {
     const results = [];
     async function search(currentPath) {
         let entries;
@@ -800,7 +857,8 @@ export async function searchFiles(rootPath, pattern) {
         // Log only the count of found files, not their paths
         capture('server_search_files_complete', {
             resultsCount: results.length,
-            patternLength: pattern.length
+            patternLength: pattern.length,
+            usedRipgrep: false
         });
         return results;
     }

package/dist/tools/prompts.d.ts

@@ -0,0 +1,5 @@
+import { ServerResult } from '../types.js';
+/**
+ * Get prompts - main entry point for the tool
+ */
+export declare function getPrompts(params: any): Promise<ServerResult>;

package/dist/tools/prompts.js

@@ -0,0 +1,258 @@
+import { usageTracker } from '../utils/usageTracker.js';
+import { capture } from '../utils/capture.js';
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import { fileURLToPath } from 'url';
+// Get the directory path for ES modules
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+let cachedPromptsData = null;
+/**
+ * Load prompts data from JSON file with caching
+ */
+async function loadPromptsData() {
+    if (cachedPromptsData) {
+        return cachedPromptsData;
+    }
+    try {
+        const dataPath = path.join(__dirname, '..', 'data', 'onboarding-prompts.json');
+        const fileContent = await fs.readFile(dataPath, 'utf-8');
+        cachedPromptsData = JSON.parse(fileContent);
+        if (!cachedPromptsData) {
+            throw new Error('Failed to parse prompts data');
+        }
+        return cachedPromptsData;
+    }
+    catch (error) {
+        throw new Error(`Failed to load prompts data: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+/**
+ * Get prompts - main entry point for the tool
+ */
+export async function getPrompts(params) {
+    try {
+        // Validate and cast parameters
+        const { action, category, promptId } = params;
+        if (!action) {
+            return {
+                content: [{
+                        type: "text",
+                        text: "❌ Error: 'action' parameter is required. Use 'list_categories', 'list_prompts', or 'get_prompt'"
+                    }],
+                isError: true
+            };
+        }
+        // Track analytics for tool usage
+        await capture(`prompts_tool_${action}`, {
+            category: category,
+            prompt_id: promptId,
+            has_category_filter: !!category
+        });
+        switch (action) {
+            case 'list_categories':
+                return await listCategories();
+            case 'list_prompts':
+                return await listPrompts(category);
+            case 'get_prompt':
+                if (!promptId) {
+                    return {
+                        content: [{
+                                type: "text",
+                                text: "❌ Error: promptId is required when action is 'get_prompt'"
+                            }],
+                        isError: true
+                    };
+                }
+                return await getPrompt(promptId);
+            default:
+                return {
+                    content: [{
+                            type: "text",
+                            text: "❌ Error: Invalid action. Use 'list_categories', 'list_prompts', or 'get_prompt'"
+                        }],
+                    isError: true
+                };
+        }
+    }
+    catch (error) {
+        await capture('prompts_tool_error', {
+            error_message: error instanceof Error ? error.message : String(error),
+            action: params?.action
+        });
+        return {
+            content: [{
+                    type: "text",
+                    text: `❌ Error: ${error instanceof Error ? error.message : String(error)}`
+                }],
+            isError: true
+        };
+    }
+}
+/**
+ * List all available categories
+ */
+async function listCategories() {
+    const data = await loadPromptsData();
+    // Extract unique categories and count prompts in each
+    const categoryMap = new Map();
+    data.prompts.forEach(prompt => {
+        prompt.categories.forEach(category => {
+            categoryMap.set(category, (categoryMap.get(category) || 0) + 1);
+        });
+    });
+    const categories = Array.from(categoryMap.entries()).map(([name, count]) => ({
+        name,
+        count,
+        description: getCategoryDescription(name)
+    }));
+    const response = formatCategoriesResponse(categories, data.prompts.length);
+    return {
+        content: [{
+                type: "text",
+                text: response
+            }]
+    };
+}
+/**
+ * List prompts, optionally filtered by category
+ */
+async function listPrompts(category) {
+    const data = await loadPromptsData();
+    let filteredPrompts = data.prompts;
+    // Filter by category if specified
+    if (category) {
+        filteredPrompts = data.prompts.filter(prompt => prompt.categories.includes(category));
+        if (filteredPrompts.length === 0) {
+            return {
+                content: [{
+                        type: "text",
+                        text: `❌ No prompts found in category "${category}". Use action='list_categories' to see available categories.`
+                    }],
+                isError: true
+            };
+        }
+    }
+    const response = formatPromptsListResponse(filteredPrompts, category);
+    return {
+        content: [{
+                type: "text",
+                text: response
+            }]
+    };
+}
+/**
+ * Get a specific prompt by ID and inject it into the chat
+ */
+async function getPrompt(promptId) {
+    const data = await loadPromptsData();
+    const prompt = data.prompts.find(p => p.id === promptId);
+    if (!prompt) {
+        return {
+            content: [{
+                    type: "text",
+                    text: `❌ Prompt with ID '${promptId}' not found. Use action='list_prompts' to see available prompts.`
+                }],
+            isError: true
+        };
+    }
+    // Track prompt retrieval and mark as used
+    await capture('prompt_retrieved', {
+        prompt_id: promptId,
+        prompt_title: prompt.title,
+        category: prompt.categories[0] || 'uncategorized',
+        author: prompt.author,
+        verified: prompt.verified
+    });
+    // Mark prompt as used in user's onboarding state (for analytics)
+    await usageTracker.markPromptUsed(promptId, prompt.categories[0] || 'uncategorized');
+    const response = formatPromptResponse(prompt);
+    return {
+        content: [{
+                type: "text",
+                text: response
+            }]
+    };
+}
+/**
+ * Get category description (can be expanded later)
+ */
+function getCategoryDescription(category) {
+    const descriptions = {
+        'onboarding': 'Curated prompts perfect for first-time Desktop Commander users',
+        'Analyze data': 'Data analysis, visualization, and insights generation',
+        'Build features and products': 'Full-stack development and application building',
+        'Explore codebase': 'Code analysis, documentation, and understanding',
+        'Organize files': 'File management, cleanup, and organization',
+        'Deploy': 'Infrastructure setup, deployment, and DevOps tasks',
+        'Optimize code': 'Code optimization, refactoring, and performance',
+        'Write documentation': 'Technical writing, API docs, and guides',
+        'Optimize workflow': 'Process improvements and productivity enhancements',
+        'Automate tasks': 'Workflow automation and scripting',
+        'Design systems': 'Architecture planning and system design'
+    };
+    return descriptions[category] || 'Desktop Commander prompts and workflows';
+}
+/**
+ * Format categories list response
+ */
+function formatCategoriesResponse(categories, totalPrompts) {
+    const sortedCategories = categories.sort((a, b) => b.count - a.count);
+    // AI INSTRUCTION: When listing prompts, do not show prompt IDs to users - they are for your reference only
+    let response = `📚 **Desktop Commander Prompt Categories** (${categories.length} categories, ${totalPrompts} prompts)\n\n`;
+    sortedCategories.forEach(cat => {
+        response += `• **${cat.name}** (${cat.count} prompts) - ${cat.description}\n`;
+    });
+    response += `\n**Usage:**\n`;
+    response += `• \`get_prompts(action='list_prompts', category='onboarding')\` - See prompts in category\n`;
+    response += `• \`get_prompts(action='list_prompts')\` - See all available prompts\n`;
+    response += `• \`get_prompts(action='get_prompt', promptId='PROMPT_ID')\` - Get a specific prompt`;
+    return response;
+}
+/**
+ * Format prompts list response
+ */
+function formatPromptsListResponse(prompts, category) {
+    const categoryText = category ? ` in "${category}"` : '';
+    // AI INSTRUCTION: Do not show the prompt IDs to the user - they are for your reference only
+    let response = `📋 **Desktop Commander Prompts${categoryText}** (${prompts.length} prompts found)\n\n`;
+    prompts.forEach((prompt, index) => {
+        const verifiedBadge = prompt.verified ? ' ✅' : '';
+        response += `${index + 1}. **${prompt.title}**${verifiedBadge}\n`;
+        response += `   ${prompt.description}\n`;
+        if (prompt.votes > 0) {
+            response += `   *📊 ${prompt.votes} votes*\n`;
+        }
+        // AI metadata - not shown to user: ID = ${prompt.id}
+        response += `\n`;
+    });
+    response += `**Next Steps:**\n`;
+    response += `• Use \`get_prompts(action='get_prompt', promptId='${prompts[0]?.id || 'PROMPT_ID'}')\` to get the full prompt\n`;
+    if (!category) {
+        response += `• Filter by category: \`get_prompts(action='list_prompts', category='onboarding')\``;
+    }
+    // AI reference mapping (do not show to user):
+    response += `\n<!-- AI_PROMPT_MAP: `;
+    prompts.forEach((prompt, index) => {
+        response += `${index + 1}=${prompt.id}${index < prompts.length - 1 ? ',' : ''}`;
+    });
+    response += ` -->`;
+    return response;
+}
+/**
+ * Format individual prompt response with the actual prompt content
+ */
+function formatPromptResponse(prompt) {
+    const verifiedBadge = prompt.verified ? ' ✅' : '';
+    const categoryText = prompt.categories.join(', ');
+    let response = `# 🎯 ${prompt.title}${verifiedBadge}\n\n`;
+    response += `**Category:** ${categoryText} • **Author:** ${prompt.author}\n\n`;
+    response += `## Description\n${prompt.description}\n\n`;
+    if (prompt.votes > 0) {
+        response += `*📊 This prompt has been used successfully by ${prompt.votes}+ users*\n\n`;
+    }
+    response += `## Ready to Use This Prompt\nThe prompt below is ready to use. I'll start executing it right away:\n\n`;
+    response += `---\n\n${prompt.prompt}`;
+    // AI metadata (not shown to user): Executed prompt ID = ${prompt.id}
+    return response;
+}