@probelabs/probe-chat 0.6.0-rc254 → 0.6.0-rc255

package/index.js

@@ -62,12 +62,7 @@ export function main() {
     .option('--json', 'Output the response as JSON in non-interactive mode')
     .option('--max-iterations <number>', 'Maximum number of tool iterations allowed (default: 30)')
     .option('--prompt <value>', 'Use a custom prompt (values: architect, code-review, code-review-template, support, path to a file, or arbitrary string)')
-    .option('--allow-edit', 'Enable the implement tool for editing files')
-    .option('--implement-tool-backend <backend>', 'Choose implementation tool backend (aider, claude-code)')
-    .option('--implement-tool-timeout <ms>', 'Implementation tool timeout in milliseconds')
-    .option('--implement-tool-config <path>', 'Path to implementation tool configuration file')
-    .option('--implement-tool-list-backends', 'List available implementation tool backends')
-    .option('--implement-tool-backend-info <backend>', 'Show information about a specific implementation tool backend')
+    .option('--allow-edit', 'Enable editing files')
     .option('--enable-bash', 'Enable bash command execution for system exploration')
     .option('--bash-allow <patterns>', 'Additional bash command patterns to allow (comma-separated)')
     .option('--bash-deny <patterns>', 'Additional bash command patterns to deny (comma-separated)')  
@@ -165,75 +160,10 @@ export function main() {
     logInfo(chalk.blue(`Setting maximum tool iterations to: ${maxIterations}`));
   }
 
-  // Handle --implement-tool-list-backends option
-  if (options.implementToolListBackends) {
-    (async () => {
-      const { listBackendNames, getBackendMetadata } = await import('./implement/backends/registry.js');
-      const backends = listBackendNames();
-      
-      console.log('\nAvailable implementation tool backends:');
-      for (const backend of backends) {
-        const metadata = getBackendMetadata(backend);
-        console.log(`\n  ${chalk.bold(backend)} - ${metadata.description}`);
-        console.log(`    Version: ${metadata.version}`);
-        console.log(`    Languages: ${metadata.capabilities.supportsLanguages.join(', ')}`);
-      }
-      process.exit(0);
-    })();
-  }
-
-  // Handle --implement-tool-backend-info option
-  if (options.implementToolBackendInfo) {
-    (async () => {
-      const { getBackendMetadata } = await import('./implement/backends/registry.js');
-      const metadata = getBackendMetadata(options.implementToolBackendInfo);
-      
-      if (!metadata) {
-        console.error(`Backend '${options.implementToolBackendInfo}' not found`);
-        process.exit(1);
-      }
-      
-      console.log(`\n${chalk.bold('Backend Information: ' + options.implementToolBackendInfo)}`);
-      console.log(`\nDescription: ${metadata.description}`);
-      console.log(`Version: ${metadata.version}`);
-      console.log(`\nCapabilities:`);
-      console.log(`  Languages: ${metadata.capabilities.supportsLanguages.join(', ')}`);
-      console.log(`  Streaming: ${metadata.capabilities.supportsStreaming ? '✓' : '✗'}`);
-      console.log(`  Direct File Edit: ${metadata.capabilities.supportsDirectFileEdit ? '✓' : '✗'}`);
-      console.log(`  Test Generation: ${metadata.capabilities.supportsTestGeneration ? '✓' : '✗'}`);
-      console.log(`  Plan Generation: ${metadata.capabilities.supportsPlanGeneration ? '✓' : '✗'}`);
-      console.log(`  Max Sessions: ${metadata.capabilities.maxConcurrentSessions}`);
-      console.log(`\nRequired Dependencies:`);
-      for (const dep of metadata.dependencies) {
-        console.log(`  - ${dep.name} (${dep.type}): ${dep.description}`);
-        if (dep.installCommand) {
-          console.log(`    Install: ${dep.installCommand}`);
-        }
-      }
-      process.exit(0);
-    })();
-  }
-
   // Set ALLOW_EDIT from command line if provided
   if (options.allowEdit) {
     process.env.ALLOW_EDIT = '1';
-    logInfo(chalk.blue(`Enabling implement tool with --allow-edit flag`));
-  }
-
-  // Set implementation tool backend options
-  if (options.implementToolBackend) {
-    process.env.IMPLEMENT_TOOL_BACKEND = options.implementToolBackend;
-    logInfo(chalk.blue(`Using implementation tool backend: ${options.implementToolBackend}`));
-  }
-  
-  if (options.implementToolTimeout) {
-    process.env.IMPLEMENT_TOOL_TIMEOUT = options.implementToolTimeout;
-    logInfo(chalk.blue(`Implementation tool timeout: ${options.implementToolTimeout}ms`));
-  }
-  
-  if (options.implementToolConfig) {
-    process.env.IMPLEMENT_TOOL_CONFIG_PATH = options.implementToolConfig;
-    logInfo(chalk.blue(`Using implementation tool config: ${options.implementToolConfig}`));
+    logInfo(chalk.blue(`Enabling edit mode with --allow-edit flag`));
   }
 
   // Set telemetry options from command line if provided

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@probelabs/probe-chat",
-  "version": "0.6.0-rc254",
+  "version": "0.6.0-rc255",
   "description": "CLI and web interface for Probe code search (formerly @probelabs/probe-web and @probelabs/probe-chat)",
   "main": "index.js",
   "type": "module",
@@ -78,7 +78,6 @@
   "files": [
     "bin/",
     "storage/",
-    "implement/",
     "test/",
     "index.js",
     "probeChat.js",

package/probeChat.js

@@ -253,7 +253,7 @@ export class ProbeChat {
    * @param {boolean} [options.isNonInteractive=false] - Suppress internal logs if true
    * @param {string} [options.customPrompt] - Custom prompt to replace the default system message
    * @param {string} [options.promptType] - Predefined prompt type (architect, code-review, support)
-   * @param {boolean} [options.allowEdit=false] - Allow the use of the 'implement' tool
+   * @param {boolean} [options.allowEdit=false] - Allow the use of the 'edit' and 'create' tools
    * @param {string} [options.architectureFileName] - Architecture context filename to embed from repo root (defaults to AGENTS.md with CLAUDE.md fallback; ARCHITECTURE.md is always included when present)
    * @param {string} [options.provider] - Force specific AI provider
    * @param {string} [options.model] - Override model name

package/probeTool.js

@@ -11,9 +11,6 @@ import { spawn } from 'child_process';
 import { randomUUID } from 'crypto';
 import { EventEmitter } from 'events';
 
-// Import the new pluggable implementation tool
-import { createImplementTool } from './implement/core/ImplementTool.js';
-
 // Create an event emitter for tool calls
 export const toolCallEmitter = new EventEmitter();
 
@@ -257,73 +254,6 @@ const wrapToolWithEmitter = (tool, toolName, baseExecute) => {
 	};
 };
 
-// Create the implement tool using the new pluggable system
-const implementToolConfig = {
-	enabled: process.env.ALLOW_EDIT === '1' || process.argv.includes('--allow-edit'),
-	backendConfig: {
-		// Configuration can be extended here
-	}
-};
-
-const pluggableImplementTool = createImplementTool(implementToolConfig);
-
-// Create a compatibility wrapper for the old interface
-const baseImplementTool = {
-	name: "implement",
-	description: pluggableImplementTool.description,
-	inputSchema: pluggableImplementTool.inputSchema,
-	execute: async ({ task, autoCommits = false, prompt, sessionId }) => {
-		const debug = process.env.DEBUG_CHAT === '1';
-		
-		if (debug) {
-			console.log(`[DEBUG] Executing implementation with task: ${task}`);
-			console.log(`[DEBUG] Auto-commits: ${autoCommits}`);
-			console.log(`[DEBUG] Session ID: ${sessionId}`);
-			if (prompt) console.log(`[DEBUG] Custom prompt: ${prompt}`);
-		}
-
-		// Check if the tool is enabled
-		if (!implementToolConfig.enabled) {
-			return {
-				success: false,
-				output: null,
-				error: 'Implementation tool is not enabled. Use --allow-edit flag to enable.',
-				command: null,
-				timestamp: new Date().toISOString(),
-				prompt: prompt || task
-			};
-		}
-
-		try {
-			// Use the new pluggable implementation tool
-			const result = await pluggableImplementTool.execute({
-				task: prompt || task, // Use prompt if provided, otherwise use task
-				autoCommit: autoCommits,
-				sessionId: sessionId,
-				// Pass through any additional options that might be useful
-				context: {
-					workingDirectory: process.cwd()
-				}
-			});
-
-			// The result is already in the expected format
-			return result;
-
-		} catch (error) {
-			// Handle any unexpected errors
-			console.error(`Error in implement tool:`, error);
-			return {
-				success: false,
-				output: null,
-				error: error.message || 'Unknown error in implementation tool',
-				command: null,
-				timestamp: new Date().toISOString(),
-				prompt: prompt || task
-			};
-		}
-	}
-};
-
 // Wrapper for listFiles tool with ALLOWED_FOLDERS security
 const baseListFilesTool = {
 	...packageListFilesToolInstance,
@@ -472,7 +402,6 @@ const baseSearchFilesTool = {
 export const searchToolInstance = wrapToolWithEmitter(baseSearchTool, 'search', baseSearchTool.execute);
 export const queryToolInstance = wrapToolWithEmitter(baseQueryTool, 'query', baseQueryTool.execute);
 export const extractToolInstance = wrapToolWithEmitter(baseExtractTool, 'extract', baseExtractTool.execute);
-export const implementToolInstance = wrapToolWithEmitter(baseImplementTool, 'implement', baseImplementTool.execute);
 export const listFilesToolInstance = wrapToolWithEmitter(baseListFilesTool, 'listFiles', baseListFilesTool.execute);
 export const searchFilesToolInstance = wrapToolWithEmitter(baseSearchFilesTool, 'searchFiles', baseSearchFilesTool.execute);
 
@@ -483,7 +412,6 @@ if (process.env.DEBUG_CHAT === '1') {
 	console.log('[DEBUG]   - search: Search for code patterns');
 	console.log('[DEBUG]   - query: Semantic code search');
 	console.log('[DEBUG]   - extract: Extract code snippets');
-	console.log('[DEBUG]   - implement: Generate code implementations');
 	console.log('[DEBUG]   - listFiles: List directory contents');
 	console.log('[DEBUG]   - searchFiles: Search files by pattern');
 	console.log('[DEBUG] ========================================\n');

package/test/integration/toolCalling.test.js

@@ -143,123 +143,6 @@ describe('Tool Calling Integration Tests', () => {
         });
     });
     
-    describe('Implement Tool', () => {
-        it('should handle implement tool calls', async () => {
-            const { probeChat, mockBackend } = await createTestProbeChat({
-                responses: [
-                    mockResponses.implementToolCall,
-                    { text: 'The implementation is complete!' }
-                ],
-                useMockBackend: true,
-                mockBackendResponses: [{
-                    filesModified: ['src/math.js'],
-                    summary: 'Added fibonacci function'
-                }]
-            });
-            
-            const results = await runChatInteraction(probeChat, 
-                [{ role: 'user', content: 'Add a fibonacci function to math.js' }]
-            );
-            
-            assert.strictEqual(results.toolCalls.length, 1);
-            assert.strictEqual(results.toolCalls[0].toolName, 'implement');
-            assert.strictEqual(mockBackend.capturedRequests.length, 1);
-            
-            const request = mockBackend.getLastRequest();
-            assert.strictEqual(request.request.request, 'Add a new function to calculate fibonacci numbers');
-            assert.deepStrictEqual(request.request.files, ['src/math.js']);
-            assert.strictEqual(request.request.backend, 'mock');
-        });
-        
-        it('should handle implement tool with streaming', async () => {
-            const { probeChat, mockBackend } = await createTestProbeChat({
-                responses: [
-                    mockResponses.implementToolCall,
-                    { text: 'Implementation completed with streaming!' }
-                ],
-                useMockBackend: true,
-                mockBackendResponses: [{
-                    stream: [
-                        { type: 'start', message: 'Starting implementation' },
-                        { type: 'progress', message: 'Generating code' },
-                        { type: 'file_update', file: 'src/math.js', action: 'modified' },
-                        { type: 'complete', message: 'Done' }
-                    ],
-                    filesModified: ['src/math.js']
-                }]
-            });
-            
-            mockBackend.setResponseDelay(50); // Fast streaming for tests
-            
-            let streamEvents = [];
-            const originalImplementExecute = probeChat.tools.implement.execute;
-            probeChat.tools.implement.execute = async function(args) {
-                return originalImplementExecute.call(this, args, {
-                    onProgress: (event) => {
-                        streamEvents.push(event);
-                    }
-                });
-            };
-            
-            await runChatInteraction(probeChat, 
-                [{ role: 'user', content: 'Implement fibonacci with streaming' }]
-            );
-            
-            assert.ok(streamEvents.length >= 4, 'Should receive multiple stream events');
-            assert.strictEqual(streamEvents[0].type, 'start');
-            assert.strictEqual(streamEvents[streamEvents.length - 1].type, 'complete');
-        });
-        
-        it('should handle backend selection', async () => {
-            const { probeChat, mockBackend } = await createTestProbeChat({
-                responses: [{
-                    text: 'I will use the mock backend.',
-                    toolCalls: [{
-                        toolName: 'implement',
-                        args: {
-                            request: 'Test backend selection',
-                            backend: 'mock'
-                        }
-                    }]
-                }, { text: 'Done with mock backend.' }],
-                useMockBackend: true
-            });
-            
-            await runChatInteraction(probeChat, 
-                [{ role: 'user', content: 'Implement something using mock backend' }]
-            );
-            
-            const request = mockBackend.getLastRequest();
-            assert.ok(request, 'Should capture the request');
-            assert.strictEqual(request.request.backend, 'mock');
-        });
-        
-        it('should handle backend errors', async () => {
-            const { probeChat, mockBackend } = await createTestProbeChat({
-                responses: [
-                    mockResponses.implementToolCall,
-                    { text: 'The implementation failed, but I handled it gracefully.' }
-                ],
-                useMockBackend: true
-            });
-            
-            mockBackend.setErrorMode(true);
-            
-            let toolError;
-            probeChat.tools.implement.handleError = (error) => {
-                toolError = error;
-            };
-            
-            const results = await runChatInteraction(probeChat, 
-                [{ role: 'user', content: 'Try to implement with error' }]
-            );
-            
-            // The tool should handle the error gracefully
-            assert.strictEqual(results.errors.length, 0, 'Chat should not error');
-            assert.ok(toolError, 'Tool should capture the error');
-        });
-    });
-    
     describe('Query Tool', () => {
         it('should handle semantic query tool calls', async () => {
             const { probeChat } = await createTestProbeChat({
@@ -417,8 +300,8 @@ describe('Tool Calling Integration Tests', () => {
     });
     
     describe('Complex Tool Sequences', () => {
-        it('should handle search → extract → implement workflow', async () => {
-            const { probeChat, mockBackend } = await createTestProbeChat({
+        it('should handle search → extract workflow', async () => {
+            const { probeChat } = await createTestProbeChat({
                 responses: [
                     {
                         text: 'Let me search for existing implementations.',
@@ -434,38 +317,24 @@ describe('Tool Calling Integration Tests', () => {
                             args: { location: 'src/math.js:fibonacci' }
                         }]
                     },
-                    {
-                        text: 'Implementing the optimized version.',
-                        toolCalls: [{
-                            toolName: 'implement',
-                            args: { 
-                                request: 'Optimize fibonacci with memoization',
-                                files: ['src/math.js'],
-                                backend: 'mock'
-                            }
-                        }]
-                    },
-                    { text: 'Successfully optimized the fibonacci function!' }
-                ],
-                useMockBackend: true
+                    { text: 'Here is the fibonacci function!' }
+                ]
             });
-            
+
             // Mock tool implementations
             probeChat.tools.probe_search.execute = async () => createMockProbeResults();
             probeChat.tools.probe_extract.execute = async () => ({
                 content: testData.sampleCode.javascript,
                 language: 'javascript'
             });
-            
-            const results = await runChatInteraction(probeChat, 
-                [{ role: 'user', content: 'Optimize the fibonacci function' }]
+
+            const results = await runChatInteraction(probeChat,
+                [{ role: 'user', content: 'Find and show the fibonacci function' }]
             );
-            
-            assert.strictEqual(results.toolCalls.length, 3);
+
+            assert.strictEqual(results.toolCalls.length, 2);
             assert.strictEqual(results.toolCalls[0].toolName, 'probe_search');
             assert.strictEqual(results.toolCalls[1].toolName, 'probe_extract');
-            assert.strictEqual(results.toolCalls[2].toolName, 'implement');
-            assert.strictEqual(mockBackend.capturedRequests.length, 1);
         });
     });
 });

package/test/mocks/mockLLMProvider.js

@@ -209,19 +209,6 @@ export const mockResponses = {
         ]
     },
 
-    // Implement tool call
-    implementToolCall: {
-        text: "I'll implement that feature for you.",
-        toolCalls: [{
-            toolName: 'implement',
-            args: {
-                request: 'Add a new function to calculate fibonacci numbers',
-                files: ['src/math.js'],
-                backend: 'mock'
-            }
-        }]
-    },
-
     // Error response
     errorResponse: {
         text: "I encountered an error processing your request.",
@@ -249,17 +236,12 @@ export function createMockProvider(scenario = 'simple', options = {}) {
             responses.push(mockResponses.withToolCall);
             responses.push(mockResponses.simpleText);
             break;
-        case 'implement':
-            responses.push(mockResponses.implementToolCall);
-            responses.push({ text: "The implementation is complete!" });
-            break;
         case 'error':
             return new MockLLMProvider({ ...options, throwError: 'Simulated API error' });
         case 'mixed':
             responses.push(mockResponses.simpleText);
             responses.push(mockResponses.withToolCall);
             responses.push(mockResponses.multipleToolCalls);
-            responses.push(mockResponses.implementToolCall);
             break;
         default:
             responses.push(mockResponses.simpleText);

package/test/test-backends.js

@@ -4,87 +4,7 @@
  * Simple test script for the pluggable backend system
  */
 
-import { createImplementTool } from '../implement/core/ImplementTool.js';
-import { listBackendNames, getBackendMetadata } from '../implement/backends/registry.js';
+// Backend test file - implement tool has been removed.
+// This file is no longer needed.
 
-async function testBackends() {
-  console.log('🧪 Testing Probe Chat Pluggable Backend System\n');
-  
-  // List available backends
-  console.log('📋 Available Backends:');
-  const backends = listBackendNames();
-  for (const backend of backends) {
-    const metadata = getBackendMetadata(backend);
-    console.log(`\n  ${backend}:`);
-    console.log(`    Version: ${metadata.version}`);
-    console.log(`    Description: ${metadata.description}`);
-    console.log(`    Languages: ${metadata.capabilities.supportsLanguages.join(', ')}`);
-  }
-  
-  console.log('\n' + '='.repeat(50) + '\n');
-  
-  // Test backend initialization
-  console.log('🔧 Testing Backend Initialization:\n');
-  
-  const tool = createImplementTool({
-    enabled: true,
-    backendConfig: {
-      defaultBackend: 'aider',
-      fallbackBackends: ['claude-code']
-    }
-  });
-  
-  try {
-    const info = await tool.getInfo();
-    console.log('✅ Backend system initialized successfully');
-    console.log(`   Default backend: ${info.defaultBackend}`);
-    console.log(`   Fallback backends: ${info.fallbackBackends.join(', ')}`);
-    console.log(`   Available backends: ${info.availableBackends.join(', ')}`);
-    
-    console.log('\n📊 Backend Health Status:');
-    for (const [name, health] of Object.entries(info.health)) {
-      console.log(`   ${name}: ${health.status} ${health.available ? '✅' : '❌'}`);
-    }
-  } catch (error) {
-    console.error('❌ Failed to initialize backend system:', error.message);
-  }
-  
-  console.log('\n' + '='.repeat(50) + '\n');
-  
-  // Test a simple implementation request (dry run)
-  console.log('🚀 Testing Implementation Request (Dry Run):\n');
-  
-  const testRequest = {
-    task: 'Create a simple hello world function in JavaScript',
-    dryRun: true,
-    sessionId: 'test-' + Date.now()
-  };
-  
-  console.log('Request:', testRequest);
-  
-  try {
-    console.log('\nExecuting request...\n');
-    const result = await tool.execute(testRequest);
-    
-    if (result.success) {
-      console.log('✅ Request executed successfully');
-      console.log(`   Backend used: ${result.backend}`);
-      console.log(`   Execution time: ${result.metrics?.executionTime}ms`);
-      console.log('\nOutput preview:');
-      console.log(result.output?.substring(0, 200) + '...');
-    } else {
-      console.log('❌ Request failed');
-      console.log(`   Error: ${result.error}`);
-    }
-  } catch (error) {
-    console.error('❌ Error executing request:', error.message);
-  }
-  
-  // Cleanup
-  await tool.cleanup();
-  
-  console.log('\n✅ Test completed');
-}
-
-// Run the test
-testBackends().catch(console.error);
+console.log('Backend tests have been removed along with the implement tool.');

package/test/testUtils.js

@@ -3,7 +3,6 @@ import path from 'path';
 import { fileURLToPath } from 'url';
 import { ProbeChat } from '../probeChat.js';
 import { MockLLMProvider, createMockStreamText } from './mocks/mockLLMProvider.js';
-import MockBackend from '../implement/backends/MockBackend.js';
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
@@ -120,20 +119,6 @@ export async function createTestProbeChat(options = {}) {
                 };
             }
         },
-        implement: {
-            execute: async (args, options) => {
-                console.log('Mock implement called with:', args);
-                return {
-                    sessionId: 'mock-session',
-                    status: 'success',
-                    filesModified: ['mock.js'],
-                    summary: 'Mock implementation complete'
-                };
-            },
-            handleError: (error) => {
-                console.error('Mock implement error:', error);
-            }
-        }
     };
     
     // Make tools accessible for test overrides
@@ -235,36 +220,6 @@ export async function createTestProbeChat(options = {}) {
         return 'mock-base64-image-data';
     };
     
-    // Register mock backend if implement tool is being tested
-    if (options.useMockBackend) {
-        const mockBackend = new MockBackend();
-        
-        if (options.mockBackendResponses) {
-            mockBackend.setResponses(options.mockBackendResponses);
-        }
-        
-        // Override the implement tool's execute method to use our mock backend
-        const originalImplementExecute = probeChat.tools.implement.execute;
-        probeChat.tools.implement.execute = async function(args, options) {
-            // Force the mock backend
-            args.backend = 'mock';
-            
-            // If we need to register the backend, do it here
-            if (this.backendManager) {
-                await this.backendManager.registerBackend(mockBackend);
-            } else {
-                // Direct execution with mock backend
-                return await mockBackend.implement(args, options);
-            }
-            
-            return originalImplementExecute ? originalImplementExecute.call(this, args, options) : 
-                   await mockBackend.implement(args, options);
-        };
-        
-        // Return both for test access
-        return { probeChat, mockProvider, mockBackend };
-    }
-    
     return { probeChat, mockProvider };
 }
 

package/test/verify-tests.js

@@ -103,7 +103,7 @@ async function main() {
         console.log('\n✅ All integration tests are working correctly!');
         console.log('\nKey features verified:');
         console.log('- Mock LLM provider with streaming support');
-        console.log('- Mock backend for implement tool');
+        console.log('- Mock backend for testing');
         console.log('- Multi-turn conversations');
         console.log('- Tool calling and execution');
         console.log('- Error handling and recovery');

package/webServer.js

@@ -13,7 +13,6 @@ import {
 	searchToolInstance, // Keep direct instances for API endpoints
 	queryToolInstance,
 	extractToolInstance,
-	implementToolInstance,
 	toolCallEmitter,
 	cancelToolExecutions,
 	clearToolExecutionData,
@@ -99,13 +98,13 @@ function getOrCreateChat(sessionId, apiCredentials = null) {
  * Start the web server
  * @param {string} version - The version of the application
  * @param {Object} options - Additional options
- * @param {boolean} options.allowEdit - Whether to allow editing files via the implement tool
+ * @param {boolean} options.allowEdit - Whether to allow editing files
  */
 export async function startWebServer(version, options = {}) {
 	const allowEdit = options?.allowEdit || false;
 
 	if (allowEdit) {
-		console.log('Edit mode enabled: implement tool is available');
+		console.log('Edit mode enabled');
 	}
 	// Authentication configuration
 	const AUTH_ENABLED = process.env.AUTH_ENABLED === '1';
@@ -155,12 +154,6 @@ export async function startWebServer(version, options = {}) {
 		query: queryToolInstance,
 		extract: extractToolInstance
 	};
-	
-	// Add implement tool if edit mode is enabled
-	if (allowEdit) {
-		directApiTools.implement = implementToolInstance;
-	}
-
 
 	// Helper function to send SSE data
 	function sendSSEData(res, data, eventType = 'message') {
@@ -214,7 +207,6 @@ export async function startWebServer(version, options = {}) {
 			'OPTIONS /api/search': (req, res) => handleOptions(res),
 			'OPTIONS /api/query': (req, res) => handleOptions(res),
 			'OPTIONS /api/extract': (req, res) => handleOptions(res),
-			'OPTIONS /api/implement': (req, res) => handleOptions(res),
 			'OPTIONS /cancel-request': (req, res) => handleOptions(res),
 			'OPTIONS /folders': (req, res) => handleOptions(res), // Added for /folders
 
@@ -641,24 +633,6 @@ export async function startWebServer(version, options = {}) {
 				});
 			},
 			
-			// Implement tool endpoint (only available if allowEdit is true)
-			'POST /api/implement': async (req, res) => {
-				// Check if edit mode is enabled
-				if (!directApiTools.implement) {
-					return sendError(res, 403, 'Implement tool is not enabled. Start server with --allow-edit to enable.');
-				}
-				
-				handlePostRequest(req, res, async (body) => {
-					const { task, sessionId: reqSessionId } = body;
-					if (!task) return sendError(res, 400, 'Missing required parameter: task');
-
-					const sessionId = reqSessionId || randomUUID();
-					const toolParams = { task, sessionId };
-
-					await executeDirectTool(res, directApiTools.implement, 'implement', toolParams, sessionId);
-				});
-			},
-
 			// --- Main Chat Endpoint (Handles the Loop) ---
 			'POST /chat': (req, res) => { // This is the route used by the frontend UI
 				handlePostRequest(req, res, async (requestData) => {