partnercore-proxy 0.1.4 → 0.4.0

package/dist/router/tool-router.js

@@ -43,6 +43,9 @@ exports.ToolRouter = void 0;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const types_js_1 = require("../config/types.js");
+const project_memory_js_1 = require("../memory/project-memory.js");
+const bc_container_js_1 = require("../container/bc-container.js");
+const git_operations_js_1 = require("../git/git-operations.js");
 const logger_js_1 = require("../utils/logger.js");
 const loader_js_1 = require("../config/loader.js");
 const security_js_1 = require("../utils/security.js");
@@ -53,6 +56,9 @@ class ToolRouter {
     routing;
     alServer = null;
     cloudClient = null;
+    projectMemory = null;
+    containerManager = null;
+    gitOperations = null;
     workspaceRoot;
     logger = (0, logger_js_1.getLogger)();
     localToolDefinitions = [];
@@ -165,6 +171,44 @@ class ToolRouter {
                     return this.handleHover(call.arguments);
                 case 'al_completion':
                     return this.handleCompletion(call.arguments);
+                // New LSP tools (Code Actions, Signature Help, Formatting)
+                case 'al_code_actions':
+                    return this.handleCodeActions(call.arguments);
+                case 'al_signature_help':
+                    return this.handleSignatureHelp(call.arguments);
+                case 'al_format':
+                    return this.handleFormat(call.arguments);
+                // Additional LSP tools (complete coverage)
+                case 'al_document_highlight':
+                    return this.handleDocumentHighlight(call.arguments);
+                case 'al_folding_ranges':
+                    return this.handleFoldingRanges(call.arguments);
+                case 'al_selection_range':
+                    return this.handleSelectionRange(call.arguments);
+                case 'al_type_definition':
+                    return this.handleTypeDefinition(call.arguments);
+                case 'al_implementation':
+                    return this.handleImplementation(call.arguments);
+                case 'al_format_on_type':
+                    return this.handleFormatOnType(call.arguments);
+                case 'al_code_lens':
+                    return this.handleCodeLens(call.arguments);
+                case 'al_document_links':
+                    return this.handleDocumentLinks(call.arguments);
+                case 'al_execute_command':
+                    return this.handleExecuteCommand(call.arguments);
+                case 'al_semantic_tokens':
+                    return this.handleSemanticTokens(call.arguments);
+                case 'al_close_document':
+                    return this.handleCloseDocument(call.arguments);
+                case 'al_save_document':
+                    return this.handleSaveDocument(call.arguments);
+                case 'al_restart_server':
+                    return this.handleRestartServer();
+                case 'al_find_referencing_symbols':
+                    return this.handleFindReferencingSymbols(call.arguments);
+                case 'al_insert_before_symbol':
+                    return this.handleInsertBeforeSymbol(call.arguments);
                 case 'read_file':
                     return this.handleReadFile(call.arguments);
                 case 'write_file':
@@ -173,6 +217,87 @@ class ToolRouter {
                     return this.handleListFiles(call.arguments);
                 case 'search_files':
                     return this.handleSearchFiles(call.arguments);
+                case 'find_file':
+                    return this.handleFindFile(call.arguments);
+                case 'replace_content':
+                    return this.handleReplaceContent(call.arguments);
+                case 'al_get_started':
+                    return this.handleGetStarted();
+                // Symbol-based editing tools
+                case 'al_rename_symbol':
+                    return this.handleRenameSymbol(call.arguments);
+                case 'al_insert_after_symbol':
+                    return this.handleInsertAfterSymbol(call.arguments);
+                case 'al_replace_symbol_body':
+                    return this.handleReplaceSymbolBody(call.arguments);
+                // Advanced file operations
+                case 'delete_lines':
+                    return this.handleDeleteLines(call.arguments);
+                case 'replace_lines':
+                    return this.handleReplaceLines(call.arguments);
+                case 'insert_at_line':
+                    return this.handleInsertAtLine(call.arguments);
+                // Project memory tools
+                case 'write_memory':
+                    return this.handleWriteMemory(call.arguments);
+                case 'read_memory':
+                    return this.handleReadMemory(call.arguments);
+                case 'list_memories':
+                    return this.handleListMemories();
+                case 'delete_memory':
+                    return this.handleDeleteMemory(call.arguments);
+                case 'edit_memory':
+                    return this.handleEditMemory(call.arguments);
+                // BC Container tools
+                case 'bc_list_containers':
+                    return this.handleListContainers();
+                case 'bc_compile':
+                    return this.handleCompile(call.arguments);
+                case 'bc_publish':
+                    return this.handlePublish(call.arguments);
+                case 'bc_run_tests':
+                    return this.handleRunTests(call.arguments);
+                case 'bc_container_logs':
+                    return this.handleContainerLogs(call.arguments);
+                case 'bc_start_container':
+                    return this.handleStartContainer(call.arguments);
+                case 'bc_stop_container':
+                    return this.handleStopContainer(call.arguments);
+                case 'bc_restart_container':
+                    return this.handleRestartContainer(call.arguments);
+                case 'bc_download_symbols':
+                    return this.handleDownloadSymbols(call.arguments);
+                case 'bc_create_container':
+                    return this.handleCreateContainer(call.arguments);
+                case 'bc_remove_container':
+                    return this.handleRemoveContainer(call.arguments);
+                case 'bc_get_extensions':
+                    return this.handleGetExtensions(call.arguments);
+                case 'bc_uninstall_app':
+                    return this.handleUninstallApp(call.arguments);
+                case 'bc_compile_warnings':
+                    return this.handleCompileWarnings(call.arguments);
+                // Git tools
+                case 'git_status':
+                    return this.handleGitStatus();
+                case 'git_diff':
+                    return this.handleGitDiff(call.arguments);
+                case 'git_stage':
+                    return this.handleGitStage(call.arguments);
+                case 'git_commit':
+                    return this.handleGitCommit(call.arguments);
+                case 'git_log':
+                    return this.handleGitLog(call.arguments);
+                case 'git_branches':
+                    return this.handleGitBranches(call.arguments);
+                case 'git_checkout':
+                    return this.handleGitCheckout(call.arguments);
+                case 'git_pull':
+                    return this.handleGitPull(call.arguments);
+                case 'git_push':
+                    return this.handleGitPush(call.arguments);
+                case 'git_stash':
+                    return this.handleGitStash(call.arguments);
                 default:
                     return {
                         success: false,
@@ -294,300 +419,2557 @@ class ToolRouter {
         const completions = await this.alServer.getCompletions(uri, line, character);
         return { success: true, content: completions };
     }
-    // ==================== File System Tool Handlers ====================
-    // All file operations are sandboxed to the workspace root for security
-    handleReadFile(args) {
-        // Validate required arguments
-        (0, security_js_1.validateToolArgs)(args, ['path'], { path: 'string' });
-        const filePath = (0, security_js_1.sanitizeString)(args['path']);
-        // Detect workspace dynamically if needed
-        const workspaceRoot = this.getWorkspaceRoot(filePath);
-        // Security: Sanitize path to prevent directory traversal
-        const resolved = (0, security_js_1.sanitizePath)(filePath, workspaceRoot);
-        if (!fs.existsSync(resolved)) {
-            return { success: false, content: `File not found: ${filePath}`, isError: true };
+    // ==================== New LSP Tool Handlers ====================
+    async handleCodeActions(args) {
+        if (!this.alServer) {
+            return { success: false, content: 'AL Language Server not initialized', isError: true };
         }
-        const stat = fs.statSync(resolved);
-        if (!stat.isFile()) {
-            return { success: false, content: `Not a file: ${filePath}`, isError: true };
+        (0, security_js_1.validateToolArgs)(args, ['uri'], { uri: 'string' });
+        const uri = args['uri'];
+        // If line/character provided, create a point range; otherwise use full diagnostics
+        let range;
+        if (args['line'] !== undefined && args['character'] !== undefined) {
+            const line = args['line'];
+            const character = args['character'];
+            range = { start: { line, character }, end: { line, character } };
         }
-        // Security: Limit file size to prevent memory exhaustion
-        const MAX_FILE_SIZE = 10 * 1024 * 1024; // 10MB
-        if (stat.size > MAX_FILE_SIZE) {
-            return { success: false, content: `File too large (max ${MAX_FILE_SIZE} bytes)`, isError: true };
+        else if (args['startLine'] !== undefined) {
+            // Range provided
+            range = {
+                start: { line: args['startLine'], character: args['startCharacter'] || 0 },
+                end: { line: args['endLine'] || args['startLine'], character: args['endCharacter'] || 0 },
+            };
         }
-        const content = fs.readFileSync(resolved, 'utf-8');
-        return { success: true, content };
-    }
-    handleWriteFile(args) {
-        // Validate required arguments
-        (0, security_js_1.validateToolArgs)(args, ['path', 'content'], { path: 'string', content: 'string' });
-        const filePath = (0, security_js_1.sanitizeString)(args['path']);
-        const content = args['content'];
-        // Detect workspace dynamically if needed
-        const workspaceRoot = this.getWorkspaceRoot(filePath);
-        // Security: Sanitize path to prevent directory traversal
-        const resolved = (0, security_js_1.sanitizePath)(filePath, workspaceRoot);
-        const dir = path.dirname(resolved);
-        // Security: Limit content size
-        const MAX_CONTENT_SIZE = 10 * 1024 * 1024; // 10MB
-        if (content.length > MAX_CONTENT_SIZE) {
-            return { success: false, content: `Content too large (max ${MAX_CONTENT_SIZE} bytes)`, isError: true };
+        else {
+            // Default to start of file
+            range = { start: { line: 0, character: 0 }, end: { line: 0, character: 0 } };
         }
-        fs.mkdirSync(dir, { recursive: true });
-        fs.writeFileSync(resolved, content, 'utf-8');
-        // Return relative path in response (don't expose full paths)
-        const relativePath = path.relative(workspaceRoot, resolved);
-        return { success: true, content: `File written: ${relativePath}` };
+        // Get diagnostics if we should include them
+        let diagnostics;
+        if (args['includeDiagnostics'] !== false) {
+            const diags = await this.alServer.getDiagnostics(uri);
+            diagnostics = diags.filter(d => {
+                // Filter to diagnostics that overlap with the range
+                return d.range.start.line <= range.end.line && d.range.end.line >= range.start.line;
+            });
+        }
+        const only = args['only'];
+        const actions = await this.alServer.getCodeActions(uri, range, { diagnostics, only });
+        return {
+            success: true,
+            content: {
+                count: actions.length,
+                actions: actions.map(a => ({
+                    title: a.title,
+                    kind: a.kind,
+                    isPreferred: a.isPreferred,
+                    hasEdit: !!a.edit,
+                    hasCommand: !!a.command,
+                })),
+                details: actions,
+            }
+        };
     }
-    handleListFiles(args) {
-        // Validate required arguments
-        (0, security_js_1.validateToolArgs)(args, ['path'], { path: 'string' });
-        const dirPath = (0, security_js_1.sanitizeString)(args['path']);
-        const pattern = args['pattern'] ? (0, security_js_1.sanitizeString)(args['pattern']) : undefined;
-        // Detect workspace dynamically if needed
-        const workspaceRoot = this.getWorkspaceRoot(dirPath);
-        // Security: Sanitize path to prevent directory traversal
-        const resolved = (0, security_js_1.sanitizePath)(dirPath, workspaceRoot);
-        if (!fs.existsSync(resolved)) {
-            return { success: false, content: `Directory not found: ${dirPath}`, isError: true };
+    async handleSignatureHelp(args) {
+        if (!this.alServer) {
+            return { success: false, content: 'AL Language Server not initialized', isError: true };
         }
-        const stat = fs.statSync(resolved);
-        if (!stat.isDirectory()) {
-            return { success: false, content: `Not a directory: ${dirPath}`, isError: true };
+        (0, security_js_1.validateToolArgs)(args, ['uri', 'line', 'character'], {
+            uri: 'string',
+            line: 'number',
+            character: 'number'
+        });
+        const uri = args['uri'];
+        const line = args['line'];
+        const character = args['character'];
+        const help = await this.alServer.getSignatureHelp(uri, line, character);
+        if (!help) {
+            return { success: true, content: { message: 'No signature help available at this position' } };
         }
-        const files = this.listFilesRecursive(resolved, pattern);
-        // Return relative paths for security
-        const relativePaths = files.map(f => path.relative(workspaceRoot, f));
-        return { success: true, content: relativePaths };
+        return {
+            success: true,
+            content: {
+                activeSignature: help.activeSignature,
+                activeParameter: help.activeParameter,
+                signatures: help.signatures.map(sig => ({
+                    label: sig.label,
+                    documentation: sig.documentation,
+                    parameters: sig.parameters?.map(p => ({
+                        label: p.label,
+                        documentation: p.documentation,
+                    })),
+                })),
+            }
+        };
     }
-    listFilesRecursive(dir, pattern, depth = 0) {
-        // Security: Limit recursion depth
-        const MAX_DEPTH = 20;
-        if (depth > MAX_DEPTH)
-            return [];
-        // Use imports from top of file (fs and path are already imported)
-        const results = [];
-        let entries;
-        try {
-            entries = fs.readdirSync(dir, { withFileTypes: true });
+    async handleFormat(args) {
+        if (!this.alServer) {
+            return { success: false, content: 'AL Language Server not initialized', isError: true };
         }
-        catch {
-            // Silently skip directories we can't read
-            return results;
+        (0, security_js_1.validateToolArgs)(args, ['uri'], { uri: 'string' });
+        const uri = args['uri'];
+        const tabSize = args['tabSize'];
+        const insertSpaces = args['insertSpaces'];
+        let edits;
+        // Check if range formatting is requested
+        if (args['startLine'] !== undefined) {
+            const range = {
+                start: {
+                    line: args['startLine'],
+                    character: args['startCharacter'] || 0
+                },
+                end: {
+                    line: args['endLine'] || args['startLine'],
+                    character: args['endCharacter'] || Number.MAX_SAFE_INTEGER
+                },
+            };
+            edits = await this.alServer.formatRange(uri, range, { tabSize, insertSpaces });
         }
-        // Security: Limit total files to prevent DoS
-        const MAX_FILES = 10000;
-        for (const entry of entries) {
-            if (results.length >= MAX_FILES)
-                break;
-            const fullPath = path.join(dir, entry.name);
-            // Security: Skip hidden files/directories and common ignored paths
-            if (entry.name.startsWith('.'))
-                continue;
-            if (entry.isDirectory()) {
-                // Skip common ignored directories
-                const ignoredDirs = ['node_modules', '.git', '.svn', 'dist', 'bin', 'obj', '.alpackages', '.snapshots'];
-                if (!ignoredDirs.includes(entry.name)) {
-                    results.push(...this.listFilesRecursive(fullPath, pattern, depth + 1));
+        else {
+            // Format entire document
+            edits = await this.alServer.formatDocument(uri, { tabSize, insertSpaces });
+        }
+        if (edits.length === 0) {
+            return { success: true, content: { message: 'Document is already formatted', edits: [] } };
+        }
+        // If apply is true, apply the edits to the file
+        if (args['apply'] === true) {
+            const filePath = this.uriToPath(uri);
+            const workspaceRoot = this.getWorkspaceRoot(filePath);
+            const safePath = (0, security_js_1.sanitizePath)(filePath, workspaceRoot);
+            let content = fs.readFileSync(safePath, 'utf-8');
+            const lines = content.split('\n');
+            // Apply edits in reverse order to maintain positions
+            const sortedEdits = [...edits].sort((a, b) => {
+                if (a.range.start.line !== b.range.start.line) {
+                    return b.range.start.line - a.range.start.line;
                 }
+                return b.range.start.character - a.range.start.character;
+            });
+            for (const edit of sortedEdits) {
+                const startLine = edit.range.start.line;
+                const endLine = edit.range.end.line;
+                const startChar = edit.range.start.character;
+                const endChar = edit.range.end.character;
+                // Get the text before and after the edit range
+                const beforeText = lines.slice(0, startLine).join('\n') +
+                    (startLine > 0 ? '\n' : '') +
+                    lines[startLine].substring(0, startChar);
+                const afterText = lines[endLine].substring(endChar) +
+                    (endLine < lines.length - 1 ? '\n' : '') +
+                    lines.slice(endLine + 1).join('\n');
+                content = beforeText + edit.newText + afterText;
+                // Re-split for next iteration
+                const newLines = content.split('\n');
+                lines.length = 0;
+                lines.push(...newLines);
             }
-            else {
-                if (!pattern || this.matchesPattern(entry.name, pattern)) {
-                    results.push(fullPath);
+            fs.writeFileSync(safePath, content, 'utf-8');
+            return {
+                success: true,
+                content: {
+                    message: `Applied ${edits.length} formatting edits`,
+                    editsApplied: edits.length,
                 }
+            };
+        }
+        return {
+            success: true,
+            content: {
+                message: `Found ${edits.length} formatting edits (use apply:true to apply)`,
+                edits: edits.map(e => ({
+                    range: e.range,
+                    newText: e.newText.length > 100 ? e.newText.substring(0, 100) + '...' : e.newText,
+                })),
             }
+        };
+    }
+    // ==================== Additional LSP Tool Handlers ====================
+    async handleDocumentHighlight(args) {
+        if (!this.alServer) {
+            return { success: false, content: 'AL Language Server not initialized', isError: true };
         }
-        return results;
+        (0, security_js_1.validateToolArgs)(args, ['uri', 'line', 'character'], {
+            uri: 'string', line: 'number', character: 'number'
+        });
+        const uri = args['uri'];
+        const line = args['line'];
+        const character = args['character'];
+        const highlights = await this.alServer.getDocumentHighlights(uri, line, character);
+        return {
+            success: true,
+            content: {
+                count: highlights.length,
+                highlights: highlights.map(h => ({
+                    range: h.range,
+                    kind: h.kind || 'text',
+                })),
+            }
+        };
     }
-    matchesPattern(filename, pattern) {
-        // Security: Escape regex special characters except * and ?
-        const escaped = pattern
-            .replace(/[.+^${}()|[\]\\]/g, '\\$&')
-            .replace(/\*/g, '.*')
-            .replace(/\?/g, '.');
-        const regex = new RegExp(`^${escaped}$`, 'i');
-        return regex.test(filename);
+    async handleFoldingRanges(args) {
+        if (!this.alServer) {
+            return { success: false, content: 'AL Language Server not initialized', isError: true };
+        }
+        (0, security_js_1.validateToolArgs)(args, ['uri'], { uri: 'string' });
+        const uri = args['uri'];
+        const ranges = await this.alServer.getFoldingRanges(uri);
+        return {
+            success: true,
+            content: {
+                count: ranges.length,
+                ranges: ranges.map(r => ({
+                    startLine: r.startLine,
+                    endLine: r.endLine,
+                    kind: r.kind,
+                })),
+            }
+        };
     }
-    handleSearchFiles(args) {
-        // Validate required arguments
-        (0, security_js_1.validateToolArgs)(args, ['path', 'query'], { path: 'string', query: 'string' });
-        const dirPath = (0, security_js_1.sanitizeString)(args['path']);
-        const query = (0, security_js_1.sanitizeString)(args['query'], 1000); // Limit query length
-        const filePattern = args['filePattern'] ? (0, security_js_1.sanitizeString)(args['filePattern']) : '*.al';
-        // Detect workspace dynamically if needed
-        const workspaceRoot = this.getWorkspaceRoot(dirPath);
-        // Security: Sanitize path
-        const resolved = (0, security_js_1.sanitizePath)(dirPath, workspaceRoot);
-        const files = this.listFilesRecursive(resolved, filePattern);
-        const results = [];
-        const queryLower = query.toLowerCase();
-        // Security: Limit results
-        const MAX_RESULTS = 500;
-        for (const file of files) {
-            if (results.length >= MAX_RESULTS)
-                break;
-            try {
-                const content = fs.readFileSync(file, 'utf-8');
-                const lines = content.split('\n');
-                lines.forEach((line, index) => {
-                    if (results.length >= MAX_RESULTS)
-                        return;
-                    if (line.toLowerCase().includes(queryLower)) {
-                        results.push({
-                            file: path.relative(workspaceRoot, file), // Return relative paths
-                            line: index + 1,
-                            content: line.trim().slice(0, 500), // Limit line length in results
-                        });
-                    }
-                });
+    async handleSelectionRange(args) {
+        if (!this.alServer) {
+            return { success: false, content: 'AL Language Server not initialized', isError: true };
+        }
+        (0, security_js_1.validateToolArgs)(args, ['uri', 'positions'], { uri: 'string' });
+        const uri = args['uri'];
+        const positions = args['positions'];
+        const ranges = await this.alServer.getSelectionRanges(uri, positions);
+        // Flatten nested parents for cleaner output
+        const flattenRange = (sr, depth = 0) => {
+            const result = [{ depth, range: sr.range }];
+            if (sr.parent && depth < 10) {
+                result.push(...flattenRange(sr.parent, depth + 1));
             }
-            catch {
-                // Skip files we can't read
+            return result;
+        };
+        return {
+            success: true,
+            content: {
+                count: ranges.length,
+                ranges: ranges.map((r, i) => ({
+                    position: positions[i],
+                    selections: flattenRange(r),
+                })),
             }
+        };
+    }
+    async handleTypeDefinition(args) {
+        if (!this.alServer) {
+            return { success: false, content: 'AL Language Server not initialized', isError: true };
         }
-        return { success: true, content: results };
+        (0, security_js_1.validateToolArgs)(args, ['uri', 'line', 'character'], {
+            uri: 'string', line: 'number', character: 'number'
+        });
+        const uri = args['uri'];
+        const line = args['line'];
+        const character = args['character'];
+        const locations = await this.alServer.getTypeDefinition(uri, line, character);
+        return {
+            success: true,
+            content: {
+                count: locations.length,
+                locations: locations.map(loc => ({
+                    uri: loc.uri,
+                    range: loc.range,
+                })),
+            }
+        };
     }
-    // ==================== Tool Definitions ====================
-    initLocalToolDefinitions() {
-        this.localToolDefinitions = [
-            {
-                name: 'al_get_symbols',
-                description: 'Get all symbols (procedures, fields, variables, etc.) in an AL file',
+    async handleImplementation(args) {
+        if (!this.alServer) {
+            return { success: false, content: 'AL Language Server not initialized', isError: true };
+        }
+        (0, security_js_1.validateToolArgs)(args, ['uri', 'line', 'character'], {
+            uri: 'string', line: 'number', character: 'number'
+        });
+        const uri = args['uri'];
+        const line = args['line'];
+        const character = args['character'];
+        const locations = await this.alServer.getImplementation(uri, line, character);
+        return {
+            success: true,
+            content: {
+                count: locations.length,
+                locations: locations.map(loc => ({
+                    uri: loc.uri,
+                    range: loc.range,
+                })),
+            }
+        };
+    }
+    async handleFormatOnType(args) {
+        if (!this.alServer) {
+            return { success: false, content: 'AL Language Server not initialized', isError: true };
+        }
+        (0, security_js_1.validateToolArgs)(args, ['uri', 'line', 'character', 'ch'], {
+            uri: 'string', line: 'number', character: 'number', ch: 'string'
+        });
+        const uri = args['uri'];
+        const line = args['line'];
+        const character = args['character'];
+        const ch = args['ch'];
+        const tabSize = args['tabSize'];
+        const insertSpaces = args['insertSpaces'];
+        const edits = await this.alServer.formatOnType(uri, line, character, ch, { tabSize, insertSpaces });
+        return {
+            success: true,
+            content: {
+                count: edits.length,
+                edits,
+            }
+        };
+    }
+    async handleCodeLens(args) {
+        if (!this.alServer) {
+            return { success: false, content: 'AL Language Server not initialized', isError: true };
+        }
+        (0, security_js_1.validateToolArgs)(args, ['uri'], { uri: 'string' });
+        const uri = args['uri'];
+        const resolve = args['resolve'];
+        let lenses = await this.alServer.getCodeLenses(uri);
+        // Optionally resolve all lenses
+        if (resolve) {
+            lenses = await Promise.all(lenses.map(lens => this.alServer.resolveCodeLens(lens)));
+        }
+        return {
+            success: true,
+            content: {
+                count: lenses.length,
+                lenses: lenses.map(l => ({
+                    range: l.range,
+                    command: l.command?.title,
+                })),
+            }
+        };
+    }
+    async handleDocumentLinks(args) {
+        if (!this.alServer) {
+            return { success: false, content: 'AL Language Server not initialized', isError: true };
+        }
+        (0, security_js_1.validateToolArgs)(args, ['uri'], { uri: 'string' });
+        const uri = args['uri'];
+        const links = await this.alServer.getDocumentLinks(uri);
+        return {
+            success: true,
+            content: {
+                count: links.length,
+                links: links.map(l => ({
+                    range: l.range,
+                    target: l.target,
+                    tooltip: l.tooltip,
+                })),
+            }
+        };
+    }
+    async handleExecuteCommand(args) {
+        if (!this.alServer) {
+            return { success: false, content: 'AL Language Server not initialized', isError: true };
+        }
+        (0, security_js_1.validateToolArgs)(args, ['command'], { command: 'string' });
+        const command = args['command'];
+        const commandArgs = args['arguments'];
+        try {
+            const result = await this.alServer.executeCommand(command, commandArgs);
+            return { success: true, content: { result } };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            return {
+                success: false,
+                content: `Command execution failed: ${errorMessage}`,
+                isError: true
+            };
+        }
+    }
+    async handleSemanticTokens(args) {
+        if (!this.alServer) {
+            return { success: false, content: 'AL Language Server not initialized', isError: true };
+        }
+        (0, security_js_1.validateToolArgs)(args, ['uri'], { uri: 'string' });
+        const uri = args['uri'];
+        // Check if range is provided
+        if (args['startLine'] !== undefined) {
+            const range = {
+                start: {
+                    line: args['startLine'],
+                    character: args['startCharacter'] || 0
+                },
+                end: {
+                    line: args['endLine'] || args['startLine'],
+                    character: args['endCharacter'] || Number.MAX_SAFE_INTEGER
+                },
+            };
+            const tokens = await this.alServer.getSemanticTokensRange(uri, range);
+            if (!tokens) {
+                return { success: true, content: { message: 'No semantic tokens available' } };
+            }
+            return {
+                success: true,
+                content: {
+                    resultId: tokens.resultId,
+                    tokenCount: tokens.data.length / 5, // Each token is 5 integers
+                    data: tokens.data.slice(0, 100), // Limit output
+                }
+            };
+        }
+        const tokens = await this.alServer.getSemanticTokens(uri);
+        if (!tokens) {
+            return { success: true, content: { message: 'No semantic tokens available' } };
+        }
+        return {
+            success: true,
+            content: {
+                resultId: tokens.resultId,
+                tokenCount: tokens.data.length / 5,
+                data: tokens.data.slice(0, 100), // Limit output for readability
+            }
+        };
+    }
+    async handleCloseDocument(args) {
+        if (!this.alServer) {
+            return { success: false, content: 'AL Language Server not initialized', isError: true };
+        }
+        (0, security_js_1.validateToolArgs)(args, ['uri'], { uri: 'string' });
+        const uri = args['uri'];
+        await this.alServer.closeDocument(uri);
+        return { success: true, content: { message: `Document closed: ${uri}` } };
+    }
+    async handleSaveDocument(args) {
+        if (!this.alServer) {
+            return { success: false, content: 'AL Language Server not initialized', isError: true };
+        }
+        (0, security_js_1.validateToolArgs)(args, ['uri'], { uri: 'string' });
+        const uri = args['uri'];
+        const text = args['text'];
+        await this.alServer.saveDocument(uri, text);
+        return { success: true, content: { message: `Document save notification sent: ${uri}` } };
+    }
+    // ==================== Extended Tool Handlers ====================
+    async handleRestartServer() {
+        if (!this.alServer) {
+            return { success: false, content: 'AL Language Server not initialized', isError: true };
+        }
+        try {
+            await this.alServer.restart();
+            return { success: true, content: { message: 'AL Language Server restarted successfully' } };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            return {
+                success: false,
+                content: `Failed to restart AL Language Server: ${errorMessage}`,
+                isError: true
+            };
+        }
+    }
+    async handleFindReferencingSymbols(args) {
+        if (!this.alServer) {
+            return { success: false, content: 'AL Language Server not initialized', isError: true };
+        }
+        (0, security_js_1.validateToolArgs)(args, ['uri', 'line', 'character'], {
+            uri: 'string', line: 'number', character: 'number'
+        });
+        const uri = args['uri'];
+        const line = args['line'];
+        const character = args['character'];
+        const includeDeclaration = args['includeDeclaration'];
+        const contextLinesBefore = args['contextLinesBefore'];
+        const contextLinesAfter = args['contextLinesAfter'];
+        const results = await this.alServer.findReferencingSymbols(uri, line, character, {
+            includeDeclaration,
+            contextLinesBefore,
+            contextLinesAfter,
+        });
+        return {
+            success: true,
+            content: {
+                count: results.length,
+                references: results.map(r => ({
+                    uri: r.location.uri,
+                    range: r.location.range,
+                    containingSymbol: r.containingSymbol ? {
+                        name: r.containingSymbol.name,
+                        kind: r.containingSymbol.kind,
+                    } : undefined,
+                    contextSnippet: r.contextSnippet,
+                })),
+            },
+        };
+    }
+    async handleInsertBeforeSymbol(args) {
+        if (!this.alServer) {
+            return { success: false, content: 'AL Language Server not initialized', isError: true };
+        }
+        (0, security_js_1.validateToolArgs)(args, ['uri', 'symbolName', 'content'], {
+            uri: 'string', symbolName: 'string', content: 'string'
+        });
+        const uri = args['uri'];
+        const symbolName = args['symbolName'];
+        const content = args['content'];
+        // Find the symbol
+        const symbol = await this.alServer.findSymbolByName(uri, symbolName);
+        if (!symbol) {
+            return {
+                success: false,
+                content: `Symbol '${symbolName}' not found in ${uri}`,
+                isError: true
+            };
+        }
+        // Read the file and insert before the symbol
+        const filePath = this.uriToPath(uri);
+        const workspaceRoot = this.getWorkspaceRoot(filePath);
+        const safePath = (0, security_js_1.sanitizePath)(filePath, workspaceRoot);
+        const fileContent = fs.readFileSync(safePath, 'utf-8');
+        const lines = fileContent.split('\n');
+        const insertLine = symbol.range.start.line;
+        const newContent = content.endsWith('\n') ? content : content + '\n';
+        lines.splice(insertLine, 0, ...newContent.split('\n').slice(0, -1));
+        fs.writeFileSync(safePath, lines.join('\n'), 'utf-8');
+        return {
+            success: true,
+            content: {
+                message: `Inserted content before symbol '${symbolName}' at line ${insertLine + 1}`,
+                insertedAt: insertLine,
+            }
+        };
+    }
+    handleFindFile(args) {
+        (0, security_js_1.validateToolArgs)(args, ['pattern'], { pattern: 'string' });
+        const pattern = args['pattern'];
+        const directory = args['directory'] || '.';
+        const workspaceRoot = this.getWorkspaceRoot();
+        const searchDir = path.resolve(workspaceRoot, directory);
+        if (!searchDir.startsWith(workspaceRoot)) {
+            return { success: false, content: 'Directory is outside workspace', isError: true };
+        }
+        const matches = [];
+        const searchRecursive = (dir) => {
+            try {
+                const entries = fs.readdirSync(dir, { withFileTypes: true });
+                for (const entry of entries) {
+                    const fullPath = path.join(dir, entry.name);
+                    if (entry.isDirectory()) {
+                        // Skip common ignored directories
+                        if (!['node_modules', '.git', '.alpackages', '.output', '.partnercore'].includes(entry.name)) {
+                            searchRecursive(fullPath);
+                        }
+                    }
+                    else if (entry.isFile()) {
+                        // Check if filename matches pattern (supports * and ? wildcards)
+                        const regex = new RegExp('^' + pattern.replace(/\*/g, '.*').replace(/\?/g, '.') + '$', 'i');
+                        if (regex.test(entry.name)) {
+                            matches.push(path.relative(workspaceRoot, fullPath));
+                        }
+                    }
+                }
+            }
+            catch {
+                // Skip inaccessible directories
+            }
+        };
+        searchRecursive(searchDir);
+        return {
+            success: true,
+            content: {
+                count: matches.length,
+                files: matches,
+            },
+        };
+    }
+    handleReplaceContent(args) {
+        (0, security_js_1.validateToolArgs)(args, ['path', 'needle', 'replacement'], {
+            path: 'string', needle: 'string', replacement: 'string'
+        });
+        const filePath = args['path'];
+        const needle = args['needle'];
+        const replacement = args['replacement'];
+        const mode = args['mode'] || 'literal';
+        const allowMultiple = args['allowMultiple'];
+        const workspaceRoot = this.getWorkspaceRoot(filePath);
+        const safePath = (0, security_js_1.sanitizePath)(filePath, workspaceRoot);
+        if (!fs.existsSync(safePath)) {
+            return { success: false, content: `File not found: ${filePath}`, isError: true };
+        }
+        let content = fs.readFileSync(safePath, 'utf-8');
+        let replacements = 0;
+        if (mode === 'regex') {
+            try {
+                const regex = new RegExp(needle, 'gm');
+                const matches = content.match(regex);
+                replacements = matches ? matches.length : 0;
+                if (replacements === 0) {
+                    return {
+                        success: false,
+                        content: `Pattern '${needle}' not found in file`,
+                        isError: true
+                    };
+                }
+                if (replacements > 1 && !allowMultiple) {
+                    return {
+                        success: false,
+                        content: `Pattern matches ${replacements} times. Set allowMultiple:true to replace all.`,
+                        isError: true
+                    };
+                }
+                content = content.replace(regex, replacement);
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : String(error);
+                return {
+                    success: false,
+                    content: `Invalid regex: ${errorMessage}`,
+                    isError: true
+                };
+            }
+        }
+        else {
+            // Literal mode
+            const occurrences = content.split(needle).length - 1;
+            if (occurrences === 0) {
+                return {
+                    success: false,
+                    content: `Text '${needle}' not found in file`,
+                    isError: true
+                };
+            }
+            if (occurrences > 1 && !allowMultiple) {
+                return {
+                    success: false,
+                    content: `Text matches ${occurrences} times. Set allowMultiple:true to replace all.`,
+                    isError: true
+                };
+            }
+            if (allowMultiple) {
+                content = content.split(needle).join(replacement);
+                replacements = occurrences;
+            }
+            else {
+                content = content.replace(needle, replacement);
+                replacements = 1;
+            }
+        }
+        fs.writeFileSync(safePath, content, 'utf-8');
+        return {
+            success: true,
+            content: {
+                message: `Replaced ${replacements} occurrence(s)`,
+                replacements,
+            },
+        };
+    }
+    handleEditMemory(args) {
+        (0, security_js_1.validateToolArgs)(args, ['name', 'needle', 'replacement'], {
+            name: 'string', needle: 'string', replacement: 'string'
+        });
+        const name = args['name'];
+        const needle = args['needle'];
+        const replacement = args['replacement'];
+        const mode = args['mode'] || 'literal';
+        const allowMultiple = args['allowMultiple'];
+        const memory = this.getProjectMemory();
+        const result = memory.editMemory(name, needle, replacement, { mode, allowMultiple });
+        return {
+            success: result.success,
+            content: result,
+            isError: !result.success,
+        };
+    }
+    async handleGetExtensions(args) {
+        (0, security_js_1.validateToolArgs)(args, ['containerName'], { containerName: 'string' });
+        const containerName = (0, security_js_1.sanitizeString)(args['containerName']);
+        const manager = this.getContainerManager();
+        const result = await manager.getExtensions(containerName);
+        return {
+            success: result.success,
+            content: result,
+            isError: !result.success,
+        };
+    }
+    async handleUninstallApp(args) {
+        (0, security_js_1.validateToolArgs)(args, ['containerName', 'name'], {
+            containerName: 'string', name: 'string'
+        });
+        const containerName = (0, security_js_1.sanitizeString)(args['containerName']);
+        const manager = this.getContainerManager();
+        const result = await manager.uninstallApp(containerName, {
+            name: args['name'],
+            publisher: args['publisher'],
+            version: args['version'],
+            force: args['force'],
+            credential: args['username'] && args['password'] ? {
+                username: args['username'],
+                password: args['password'],
+            } : undefined,
+        });
+        return {
+            success: result.success,
+            content: result,
+            isError: !result.success,
+        };
+    }
+    async handleCompileWarnings(args) {
+        (0, security_js_1.validateToolArgs)(args, ['containerName'], { containerName: 'string' });
+        const containerName = (0, security_js_1.sanitizeString)(args['containerName']);
+        const manager = this.getContainerManager();
+        const result = await manager.compileWarningsOnly(containerName, {
+            appProjectFolder: args['appProjectFolder'],
+        });
+        return {
+            success: result.success,
+            content: result,
+            isError: !result.success,
+        };
+    }
+    uriToPath(uri) {
+        if (uri.startsWith('file:///')) {
+            // Windows: file:///C:/path -> C:/path
+            const path = uri.slice(8);
+            // Handle URL encoding
+            return decodeURIComponent(path);
+        }
+        return uri;
+    }
+    // ==================== File System Tool Handlers ====================
+    // All file operations are sandboxed to the workspace root for security
+    handleReadFile(args) {
+        // Validate required arguments
+        (0, security_js_1.validateToolArgs)(args, ['path'], { path: 'string' });
+        const filePath = (0, security_js_1.sanitizeString)(args['path']);
+        // Detect workspace dynamically if needed
+        const workspaceRoot = this.getWorkspaceRoot(filePath);
+        // Security: Sanitize path to prevent directory traversal
+        const resolved = (0, security_js_1.sanitizePath)(filePath, workspaceRoot);
+        if (!fs.existsSync(resolved)) {
+            return { success: false, content: `File not found: ${filePath}`, isError: true };
+        }
+        const stat = fs.statSync(resolved);
+        if (!stat.isFile()) {
+            return { success: false, content: `Not a file: ${filePath}`, isError: true };
+        }
+        // Security: Limit file size to prevent memory exhaustion
+        const MAX_FILE_SIZE = 10 * 1024 * 1024; // 10MB
+        if (stat.size > MAX_FILE_SIZE) {
+            return { success: false, content: `File too large (max ${MAX_FILE_SIZE} bytes)`, isError: true };
+        }
+        const content = fs.readFileSync(resolved, 'utf-8');
+        return { success: true, content };
+    }
+    handleWriteFile(args) {
+        // Validate required arguments
+        (0, security_js_1.validateToolArgs)(args, ['path', 'content'], { path: 'string', content: 'string' });
+        const filePath = (0, security_js_1.sanitizeString)(args['path']);
+        const content = args['content'];
+        // Detect workspace dynamically if needed
+        const workspaceRoot = this.getWorkspaceRoot(filePath);
+        // Security: Sanitize path to prevent directory traversal
+        const resolved = (0, security_js_1.sanitizePath)(filePath, workspaceRoot);
+        const dir = path.dirname(resolved);
+        // Security: Limit content size
+        const MAX_CONTENT_SIZE = 10 * 1024 * 1024; // 10MB
+        if (content.length > MAX_CONTENT_SIZE) {
+            return { success: false, content: `Content too large (max ${MAX_CONTENT_SIZE} bytes)`, isError: true };
+        }
+        fs.mkdirSync(dir, { recursive: true });
+        fs.writeFileSync(resolved, content, 'utf-8');
+        // Return relative path in response (don't expose full paths)
+        const relativePath = path.relative(workspaceRoot, resolved);
+        return { success: true, content: `File written: ${relativePath}` };
+    }
+    handleListFiles(args) {
+        // Validate required arguments
+        (0, security_js_1.validateToolArgs)(args, ['path'], { path: 'string' });
+        const dirPath = (0, security_js_1.sanitizeString)(args['path']);
+        const pattern = args['pattern'] ? (0, security_js_1.sanitizeString)(args['pattern']) : undefined;
+        // Detect workspace dynamically if needed
+        const workspaceRoot = this.getWorkspaceRoot(dirPath);
+        // Security: Sanitize path to prevent directory traversal
+        const resolved = (0, security_js_1.sanitizePath)(dirPath, workspaceRoot);
+        if (!fs.existsSync(resolved)) {
+            return { success: false, content: `Directory not found: ${dirPath}`, isError: true };
+        }
+        const stat = fs.statSync(resolved);
+        if (!stat.isDirectory()) {
+            return { success: false, content: `Not a directory: ${dirPath}`, isError: true };
+        }
+        const files = this.listFilesRecursive(resolved, pattern);
+        // Return relative paths for security
+        const relativePaths = files.map(f => path.relative(workspaceRoot, f));
+        return { success: true, content: relativePaths };
+    }
+    listFilesRecursive(dir, pattern, depth = 0) {
+        // Security: Limit recursion depth
+        const MAX_DEPTH = 20;
+        if (depth > MAX_DEPTH)
+            return [];
+        // Use imports from top of file (fs and path are already imported)
+        const results = [];
+        let entries;
+        try {
+            entries = fs.readdirSync(dir, { withFileTypes: true });
+        }
+        catch {
+            // Silently skip directories we can't read
+            return results;
+        }
+        // Security: Limit total files to prevent DoS
+        const MAX_FILES = 10000;
+        for (const entry of entries) {
+            if (results.length >= MAX_FILES)
+                break;
+            const fullPath = path.join(dir, entry.name);
+            // Security: Skip hidden files/directories and common ignored paths
+            if (entry.name.startsWith('.'))
+                continue;
+            if (entry.isDirectory()) {
+                // Skip common ignored directories
+                const ignoredDirs = ['node_modules', '.git', '.svn', 'dist', 'bin', 'obj', '.alpackages', '.snapshots'];
+                if (!ignoredDirs.includes(entry.name)) {
+                    results.push(...this.listFilesRecursive(fullPath, pattern, depth + 1));
+                }
+            }
+            else {
+                if (!pattern || this.matchesPattern(entry.name, pattern)) {
+                    results.push(fullPath);
+                }
+            }
+        }
+        return results;
+    }
+    matchesPattern(filename, pattern) {
+        // Security: Escape regex special characters except * and ?
+        const escaped = pattern
+            .replace(/[.+^${}()|[\]\\]/g, '\\$&')
+            .replace(/\*/g, '.*')
+            .replace(/\?/g, '.');
+        const regex = new RegExp(`^${escaped}$`, 'i');
+        return regex.test(filename);
+    }
+    handleSearchFiles(args) {
+        // Validate required arguments
+        (0, security_js_1.validateToolArgs)(args, ['path', 'query'], { path: 'string', query: 'string' });
+        const dirPath = (0, security_js_1.sanitizeString)(args['path']);
+        const query = (0, security_js_1.sanitizeString)(args['query'], 1000); // Limit query length
+        const filePattern = args['filePattern'] ? (0, security_js_1.sanitizeString)(args['filePattern']) : '*.al';
+        // Detect workspace dynamically if needed
+        const workspaceRoot = this.getWorkspaceRoot(dirPath);
+        // Security: Sanitize path
+        const resolved = (0, security_js_1.sanitizePath)(dirPath, workspaceRoot);
+        const files = this.listFilesRecursive(resolved, filePattern);
+        const results = [];
+        const queryLower = query.toLowerCase();
+        // Security: Limit results
+        const MAX_RESULTS = 500;
+        for (const file of files) {
+            if (results.length >= MAX_RESULTS)
+                break;
+            try {
+                const content = fs.readFileSync(file, 'utf-8');
+                const lines = content.split('\n');
+                lines.forEach((line, index) => {
+                    if (results.length >= MAX_RESULTS)
+                        return;
+                    if (line.toLowerCase().includes(queryLower)) {
+                        results.push({
+                            file: path.relative(workspaceRoot, file), // Return relative paths
+                            line: index + 1,
+                            content: line.trim().slice(0, 500), // Limit line length in results
+                        });
+                    }
+                });
+            }
+            catch {
+                // Skip files we can't read
+            }
+        }
+        return { success: true, content: results };
+    }
+    // ==================== Symbol-Based Editing Handlers ====================
+    async handleRenameSymbol(args) {
+        if (!this.alServer) {
+            return { success: false, content: 'AL Language Server not initialized', isError: true };
+        }
+        (0, security_js_1.validateToolArgs)(args, ['uri', 'line', 'character', 'newName'], {
+            uri: 'string', line: 'number', character: 'number', newName: 'string'
+        });
+        const uri = args['uri'];
+        const line = args['line'];
+        const character = args['character'];
+        const newName = (0, security_js_1.sanitizeString)(args['newName']);
+        const workspaceEdit = await this.alServer.renameSymbol(uri, line, character, newName);
+        if (!workspaceEdit) {
+            return { success: false, content: 'Rename not available at this position', isError: true };
+        }
+        // Apply the edits
+        const appliedFiles = [];
+        if (workspaceEdit.changes) {
+            for (const [fileUri, edits] of Object.entries(workspaceEdit.changes)) {
+                const filePath = this.uriToPath(fileUri);
+                let content = fs.readFileSync(filePath, 'utf-8');
+                // Apply edits in reverse order to preserve positions
+                const sortedEdits = [...edits].sort((a, b) => {
+                    if (a.range.start.line !== b.range.start.line) {
+                        return b.range.start.line - a.range.start.line;
+                    }
+                    return b.range.start.character - a.range.start.character;
+                });
+                const lines = content.split('\n');
+                for (const edit of sortedEdits) {
+                    const startLine = edit.range.start.line;
+                    const endLine = edit.range.end.line;
+                    const startChar = edit.range.start.character;
+                    const endChar = edit.range.end.character;
+                    if (startLine === endLine) {
+                        // Single line edit
+                        const line = lines[startLine];
+                        lines[startLine] = line.slice(0, startChar) + edit.newText + line.slice(endChar);
+                    }
+                    else {
+                        // Multi-line edit
+                        const firstLine = lines[startLine].slice(0, startChar);
+                        const lastLine = lines[endLine].slice(endChar);
+                        const newLines = edit.newText.split('\n');
+                        newLines[0] = firstLine + newLines[0];
+                        newLines[newLines.length - 1] += lastLine;
+                        lines.splice(startLine, endLine - startLine + 1, ...newLines);
+                    }
+                }
+                content = lines.join('\n');
+                fs.writeFileSync(filePath, content, 'utf-8');
+                appliedFiles.push(filePath);
+            }
+        }
+        return {
+            success: true,
+            content: {
+                message: `Renamed symbol to '${newName}'`,
+                filesModified: appliedFiles.length,
+                files: appliedFiles,
+            }
+        };
+    }
+    async handleInsertAfterSymbol(args) {
+        if (!this.alServer) {
+            return { success: false, content: 'AL Language Server not initialized', isError: true };
+        }
+        (0, security_js_1.validateToolArgs)(args, ['uri', 'symbolName', 'content'], {
+            uri: 'string', symbolName: 'string', content: 'string'
+        });
+        const uri = args['uri'];
+        const symbolName = (0, security_js_1.sanitizeString)(args['symbolName']);
+        const insertContent = args['content'];
+        const filePath = this.uriToPath(uri);
+        // Find the symbol
+        const symbol = await this.alServer.findSymbolByName(uri, symbolName);
+        if (!symbol) {
+            return { success: false, content: `Symbol '${symbolName}' not found`, isError: true };
+        }
+        // Read the file and insert after the symbol's end
+        let content = fs.readFileSync(filePath, 'utf-8');
+        const lines = content.split('\n');
+        const insertLine = symbol.range.end.line;
+        // Insert the new content after the symbol
+        lines.splice(insertLine + 1, 0, '', insertContent);
+        content = lines.join('\n');
+        fs.writeFileSync(filePath, content, 'utf-8');
+        const workspaceRoot = this.getWorkspaceRoot(filePath);
+        const relativePath = path.relative(workspaceRoot, filePath);
+        return {
+            success: true,
+            content: {
+                message: `Inserted content after symbol '${symbolName}'`,
+                file: relativePath,
+                insertedAtLine: insertLine + 2, // 1-based
+            }
+        };
+    }
+    async handleReplaceSymbolBody(args) {
+        if (!this.alServer) {
+            return { success: false, content: 'AL Language Server not initialized', isError: true };
+        }
+        (0, security_js_1.validateToolArgs)(args, ['uri', 'symbolName', 'newBody'], {
+            uri: 'string', symbolName: 'string', newBody: 'string'
+        });
+        const uri = args['uri'];
+        const symbolName = (0, security_js_1.sanitizeString)(args['symbolName']);
+        const newBody = args['newBody'];
+        const filePath = this.uriToPath(uri);
+        // Find the symbol
+        const symbol = await this.alServer.findSymbolByName(uri, symbolName);
+        if (!symbol) {
+            return { success: false, content: `Symbol '${symbolName}' not found`, isError: true };
+        }
+        // Read the file and replace the symbol's range
+        let content = fs.readFileSync(filePath, 'utf-8');
+        const lines = content.split('\n');
+        const startLine = symbol.range.start.line;
+        const endLine = symbol.range.end.line;
+        const startChar = symbol.range.start.character;
+        const endChar = symbol.range.end.character;
+        // Replace the symbol body
+        const before = lines.slice(0, startLine).join('\n');
+        const firstLinePart = lines[startLine].slice(0, startChar);
+        const lastLinePart = lines[endLine].slice(endChar);
+        const after = lines.slice(endLine + 1).join('\n');
+        content = before + (before ? '\n' : '') + firstLinePart + newBody + lastLinePart + (after ? '\n' + after : '');
+        fs.writeFileSync(filePath, content, 'utf-8');
+        const workspaceRoot = this.getWorkspaceRoot(filePath);
+        const relativePath = path.relative(workspaceRoot, filePath);
+        return {
+            success: true,
+            content: {
+                message: `Replaced body of symbol '${symbolName}'`,
+                file: relativePath,
+                linesReplaced: endLine - startLine + 1,
+            }
+        };
+    }
+    // ==================== Advanced File Operations ====================
+    handleDeleteLines(args) {
+        (0, security_js_1.validateToolArgs)(args, ['path', 'startLine', 'endLine'], {
+            path: 'string', startLine: 'number', endLine: 'number'
+        });
+        const filePath = (0, security_js_1.sanitizeString)(args['path']);
+        const startLine = args['startLine']; // 1-based
+        const endLine = args['endLine']; // 1-based
+        const workspaceRoot = this.getWorkspaceRoot(filePath);
+        const resolved = (0, security_js_1.sanitizePath)(filePath, workspaceRoot);
+        if (!fs.existsSync(resolved)) {
+            return { success: false, content: `File not found: ${filePath}`, isError: true };
+        }
+        let content = fs.readFileSync(resolved, 'utf-8');
+        const lines = content.split('\n');
+        if (startLine < 1 || endLine > lines.length || startLine > endLine) {
+            return { success: false, content: `Invalid line range: ${startLine}-${endLine}`, isError: true };
+        }
+        // Delete lines (convert to 0-based)
+        lines.splice(startLine - 1, endLine - startLine + 1);
+        content = lines.join('\n');
+        fs.writeFileSync(resolved, content, 'utf-8');
+        const relativePath = path.relative(workspaceRoot, resolved);
+        return {
+            success: true,
+            content: {
+                message: `Deleted lines ${startLine}-${endLine}`,
+                file: relativePath,
+                linesDeleted: endLine - startLine + 1,
+            }
+        };
+    }
+    handleReplaceLines(args) {
+        (0, security_js_1.validateToolArgs)(args, ['path', 'startLine', 'endLine', 'newContent'], {
+            path: 'string', startLine: 'number', endLine: 'number', newContent: 'string'
+        });
+        const filePath = (0, security_js_1.sanitizeString)(args['path']);
+        const startLine = args['startLine']; // 1-based
+        const endLine = args['endLine']; // 1-based
+        const newContent = args['newContent'];
+        const workspaceRoot = this.getWorkspaceRoot(filePath);
+        const resolved = (0, security_js_1.sanitizePath)(filePath, workspaceRoot);
+        if (!fs.existsSync(resolved)) {
+            return { success: false, content: `File not found: ${filePath}`, isError: true };
+        }
+        let content = fs.readFileSync(resolved, 'utf-8');
+        const lines = content.split('\n');
+        if (startLine < 1 || endLine > lines.length || startLine > endLine) {
+            return { success: false, content: `Invalid line range: ${startLine}-${endLine}`, isError: true };
+        }
+        // Replace lines (convert to 0-based)
+        const newLines = newContent.split('\n');
+        lines.splice(startLine - 1, endLine - startLine + 1, ...newLines);
+        content = lines.join('\n');
+        fs.writeFileSync(resolved, content, 'utf-8');
+        const relativePath = path.relative(workspaceRoot, resolved);
+        return {
+            success: true,
+            content: {
+                message: `Replaced lines ${startLine}-${endLine}`,
+                file: relativePath,
+                linesReplaced: endLine - startLine + 1,
+                newLinesCount: newLines.length,
+            }
+        };
+    }
+    handleInsertAtLine(args) {
+        (0, security_js_1.validateToolArgs)(args, ['path', 'line', 'content'], {
+            path: 'string', line: 'number', content: 'string'
+        });
+        const filePath = (0, security_js_1.sanitizeString)(args['path']);
+        const lineNumber = args['line']; // 1-based
+        const insertContent = args['content'];
+        const workspaceRoot = this.getWorkspaceRoot(filePath);
+        const resolved = (0, security_js_1.sanitizePath)(filePath, workspaceRoot);
+        if (!fs.existsSync(resolved)) {
+            return { success: false, content: `File not found: ${filePath}`, isError: true };
+        }
+        let content = fs.readFileSync(resolved, 'utf-8');
+        const lines = content.split('\n');
+        if (lineNumber < 1 || lineNumber > lines.length + 1) {
+            return { success: false, content: `Invalid line number: ${lineNumber}`, isError: true };
+        }
+        // Insert at line (convert to 0-based)
+        const newLines = insertContent.split('\n');
+        lines.splice(lineNumber - 1, 0, ...newLines);
+        content = lines.join('\n');
+        fs.writeFileSync(resolved, content, 'utf-8');
+        const relativePath = path.relative(workspaceRoot, resolved);
+        return {
+            success: true,
+            content: {
+                message: `Inserted ${newLines.length} line(s) at line ${lineNumber}`,
+                file: relativePath,
+                linesInserted: newLines.length,
+            }
+        };
+    }
+    // ==================== Project Memory Handlers ====================
+    getProjectMemory() {
+        if (!this.projectMemory) {
+            const workspaceRoot = this.getWorkspaceRoot();
+            this.projectMemory = new project_memory_js_1.ProjectMemory(workspaceRoot);
+        }
+        return this.projectMemory;
+    }
+    handleWriteMemory(args) {
+        (0, security_js_1.validateToolArgs)(args, ['name', 'content'], { name: 'string', content: 'string' });
+        const name = (0, security_js_1.sanitizeString)(args['name']);
+        const content = args['content'];
+        const tags = args['tags'];
+        const memory = this.getProjectMemory();
+        const result = memory.writeMemory(name, content, tags);
+        return {
+            success: true,
+            content: {
+                message: `Memory '${name}' saved`,
+                memory: {
+                    name: result.name,
+                    createdAt: result.createdAt,
+                    updatedAt: result.updatedAt,
+                    tags: result.tags,
+                }
+            }
+        };
+    }
+    handleReadMemory(args) {
+        (0, security_js_1.validateToolArgs)(args, ['name'], { name: 'string' });
+        const name = (0, security_js_1.sanitizeString)(args['name']);
+        const memory = this.getProjectMemory();
+        const result = memory.readMemory(name);
+        if (!result) {
+            return { success: false, content: `Memory '${name}' not found`, isError: true };
+        }
+        return {
+            success: true,
+            content: result
+        };
+    }
+    handleListMemories() {
+        const memory = this.getProjectMemory();
+        const memories = memory.listMemories();
+        return {
+            success: true,
+            content: {
+                count: memories.length,
+                memories: memories.map(m => ({
+                    name: m.name,
+                    updatedAt: m.updatedAt,
+                    tags: m.tags,
+                    preview: m.content.slice(0, 100) + (m.content.length > 100 ? '...' : ''),
+                })),
+            }
+        };
+    }
+    handleDeleteMemory(args) {
+        (0, security_js_1.validateToolArgs)(args, ['name'], { name: 'string' });
+        const name = (0, security_js_1.sanitizeString)(args['name']);
+        const memory = this.getProjectMemory();
+        const deleted = memory.deleteMemory(name);
+        if (!deleted) {
+            return { success: false, content: `Memory '${name}' not found`, isError: true };
+        }
+        return {
+            success: true,
+            content: { message: `Memory '${name}' deleted` }
+        };
+    }
+    // ==================== BC Container Handlers ====================
+    getContainerManager() {
+        if (!this.containerManager) {
+            const workspaceRoot = this.getWorkspaceRoot();
+            this.containerManager = new bc_container_js_1.BCContainerManager(workspaceRoot);
+        }
+        return this.containerManager;
+    }
+    async handleListContainers() {
+        const manager = this.getContainerManager();
+        const containers = await manager.listContainers();
+        return {
+            success: true,
+            content: {
+                count: containers.length,
+                containers: containers.map(c => ({
+                    name: c.name,
+                    image: c.image,
+                    status: c.status,
+                    running: c.running,
+                    ports: c.ports,
+                })),
+            }
+        };
+    }
+    async handleCompile(args) {
+        (0, security_js_1.validateToolArgs)(args, ['containerName'], { containerName: 'string' });
+        const containerName = (0, security_js_1.sanitizeString)(args['containerName']);
+        const manager = this.getContainerManager();
+        const result = await manager.compile(containerName, {
+            appProjectFolder: args['appProjectFolder'],
+            outputFolder: args['outputFolder'],
+        });
+        return {
+            success: result.success,
+            content: {
+                success: result.success,
+                appFile: result.appFile,
+                errors: result.errors,
+                warnings: result.warnings,
+                duration: `${(result.duration / 1000).toFixed(2)}s`,
+            },
+            isError: !result.success,
+        };
+    }
+    async handlePublish(args) {
+        (0, security_js_1.validateToolArgs)(args, ['containerName'], { containerName: 'string' });
+        const containerName = (0, security_js_1.sanitizeString)(args['containerName']);
+        const manager = this.getContainerManager();
+        const result = await manager.publish(containerName, {
+            appFile: args['appFile'],
+            syncMode: args['syncMode'],
+            skipVerification: args['skipVerification'],
+            install: args['install'],
+        });
+        return {
+            success: result.success,
+            content: result,
+            isError: !result.success,
+        };
+    }
+    async handleRunTests(args) {
+        (0, security_js_1.validateToolArgs)(args, ['containerName'], { containerName: 'string' });
+        const containerName = (0, security_js_1.sanitizeString)(args['containerName']);
+        const manager = this.getContainerManager();
+        const result = await manager.runTests(containerName, {
+            testCodeunit: args['testCodeunit'],
+            testFunction: args['testFunction'],
+            extensionId: args['extensionId'],
+            detailed: args['detailed'],
+        });
+        return {
+            success: result.success,
+            content: {
+                success: result.success,
+                testsRun: result.testsRun,
+                testsPassed: result.testsPassed,
+                testsFailed: result.testsFailed,
+                testsSkipped: result.testsSkipped,
+                duration: `${(result.duration / 1000).toFixed(2)}s`,
+                results: result.results.slice(0, 50), // Limit results to prevent huge payloads
+            },
+            isError: !result.success,
+        };
+    }
+    async handleContainerLogs(args) {
+        (0, security_js_1.validateToolArgs)(args, ['containerName'], { containerName: 'string' });
+        const containerName = (0, security_js_1.sanitizeString)(args['containerName']);
+        const manager = this.getContainerManager();
+        const logs = await manager.getLogs(containerName, {
+            tail: args['tail'],
+            since: args['since'],
+        });
+        return {
+            success: true,
+            content: logs,
+        };
+    }
+    async handleStartContainer(args) {
+        (0, security_js_1.validateToolArgs)(args, ['containerName'], { containerName: 'string' });
+        const containerName = (0, security_js_1.sanitizeString)(args['containerName']);
+        const manager = this.getContainerManager();
+        const result = await manager.startContainer(containerName);
+        return {
+            success: result.success,
+            content: result,
+            isError: !result.success,
+        };
+    }
+    async handleStopContainer(args) {
+        (0, security_js_1.validateToolArgs)(args, ['containerName'], { containerName: 'string' });
+        const containerName = (0, security_js_1.sanitizeString)(args['containerName']);
+        const manager = this.getContainerManager();
+        const result = await manager.stopContainer(containerName);
+        return {
+            success: result.success,
+            content: result,
+            isError: !result.success,
+        };
+    }
+    async handleRestartContainer(args) {
+        (0, security_js_1.validateToolArgs)(args, ['containerName'], { containerName: 'string' });
+        const containerName = (0, security_js_1.sanitizeString)(args['containerName']);
+        const manager = this.getContainerManager();
+        const result = await manager.restartContainer(containerName);
+        return {
+            success: result.success,
+            content: result,
+            isError: !result.success,
+        };
+    }
+    async handleDownloadSymbols(args) {
+        (0, security_js_1.validateToolArgs)(args, ['containerName'], { containerName: 'string' });
+        const containerName = (0, security_js_1.sanitizeString)(args['containerName']);
+        const manager = this.getContainerManager();
+        const result = await manager.downloadSymbols(containerName, args['targetFolder']);
+        return {
+            success: result.success,
+            content: result,
+            isError: !result.success,
+        };
+    }
+    async handleCreateContainer(args) {
+        (0, security_js_1.validateToolArgs)(args, ['containerName'], { containerName: 'string' });
+        const containerName = (0, security_js_1.sanitizeString)(args['containerName']);
+        const manager = this.getContainerManager();
+        // Build options from arguments
+        const options = {
+            artifactUrl: args['artifactUrl'],
+            version: args['version'],
+            country: args['country'],
+            type: args['type'],
+            auth: args['auth'],
+            credential: args['username'] && args['password'] ? {
+                username: args['username'],
+                password: args['password'],
+            } : undefined,
+            licenseFile: args['licenseFile'],
+            accept_eula: args['accept_eula'] !== false,
+            accept_outdated: args['accept_outdated'],
+            includeTestToolkit: args['includeTestToolkit'],
+            includeTestLibrariesOnly: args['includeTestLibrariesOnly'],
+            includeTestFrameworkOnly: args['includeTestFrameworkOnly'],
+            enableTaskScheduler: args['enableTaskScheduler'],
+            assignPremiumPlan: args['assignPremiumPlan'],
+            multitenant: args['multitenant'],
+            memoryLimit: args['memoryLimit'],
+            isolation: args['isolation'],
+            updateHosts: args['updateHosts'],
+        };
+        const result = await manager.createContainer(containerName, options);
+        return {
+            success: result.success,
+            content: result,
+            isError: !result.success,
+        };
+    }
+    async handleRemoveContainer(args) {
+        (0, security_js_1.validateToolArgs)(args, ['containerName'], { containerName: 'string' });
+        const containerName = (0, security_js_1.sanitizeString)(args['containerName']);
+        const force = args['force'];
+        const manager = this.getContainerManager();
+        const result = await manager.removeContainer(containerName, force);
+        return {
+            success: result.success,
+            content: result,
+            isError: !result.success,
+        };
+    }
+    // ==================== Git Operations Handlers ====================
+    getGitOperations() {
+        if (!this.gitOperations) {
+            const workspaceRoot = this.getWorkspaceRoot();
+            this.gitOperations = new git_operations_js_1.GitOperations(workspaceRoot);
+        }
+        return this.gitOperations;
+    }
+    async handleGitStatus() {
+        const git = this.getGitOperations();
+        if (!await git.isGitRepository()) {
+            return { success: false, content: 'Not a git repository', isError: true };
+        }
+        const status = await git.getStatus();
+        return { success: true, content: status };
+    }
+    async handleGitDiff(args) {
+        const git = this.getGitOperations();
+        const diff = await git.getDiff({
+            staged: args['staged'],
+            file: args['file'],
+            unified: args['unified'],
+        });
+        return {
+            success: true,
+            content: diff || '(No changes)',
+        };
+    }
+    async handleGitStage(args) {
+        (0, security_js_1.validateToolArgs)(args, ['paths'], {});
+        const git = this.getGitOperations();
+        const paths = args['paths'];
+        const result = await git.stage(paths);
+        return {
+            success: result.success,
+            content: result,
+            isError: !result.success,
+        };
+    }
+    async handleGitCommit(args) {
+        (0, security_js_1.validateToolArgs)(args, ['message'], { message: 'string' });
+        const git = this.getGitOperations();
+        const message = args['message'];
+        const result = await git.commit(message, {
+            amend: args['amend'],
+            allowEmpty: args['allowEmpty'],
+        });
+        return {
+            success: result.success,
+            content: result,
+            isError: !result.success,
+        };
+    }
+    async handleGitLog(args) {
+        const git = this.getGitOperations();
+        const commits = await git.getLog({
+            limit: args['limit'] || 20,
+            since: args['since'],
+            author: args['author'],
+            grep: args['grep'],
+            file: args['file'],
+        });
+        return {
+            success: true,
+            content: {
+                count: commits.length,
+                commits,
+            }
+        };
+    }
+    async handleGitBranches(args) {
+        const git = this.getGitOperations();
+        const remote = args['remote'];
+        const branches = await git.listBranches(remote);
+        const currentBranch = branches.find(b => b.current);
+        return {
+            success: true,
+            content: {
+                current: currentBranch?.name,
+                count: branches.length,
+                branches,
+            }
+        };
+    }
+    async handleGitCheckout(args) {
+        (0, security_js_1.validateToolArgs)(args, ['target'], { target: 'string' });
+        const git = this.getGitOperations();
+        const target = (0, security_js_1.sanitizeString)(args['target']);
+        const result = await git.checkout(target, {
+            create: args['create'],
+        });
+        return {
+            success: result.success,
+            content: result,
+            isError: !result.success,
+        };
+    }
+    async handleGitPull(args) {
+        const git = this.getGitOperations();
+        const result = await git.pull({
+            remote: args['remote'],
+            branch: args['branch'],
+            rebase: args['rebase'],
+        });
+        return {
+            success: result.success,
+            content: result,
+            isError: !result.success,
+        };
+    }
+    async handleGitPush(args) {
+        const git = this.getGitOperations();
+        const result = await git.push({
+            remote: args['remote'],
+            branch: args['branch'],
+            setUpstream: args['setUpstream'],
+            force: args['force'],
+        });
+        return {
+            success: result.success,
+            content: result,
+            isError: !result.success,
+        };
+    }
+    async handleGitStash(args) {
+        const git = this.getGitOperations();
+        const action = args['action'] || 'list';
+        switch (action) {
+            case 'save':
+            case 'push': {
+                const result = await git.stash({
+                    message: args['message'],
+                    includeUntracked: args['includeUntracked'],
+                });
+                return { success: result.success, content: result, isError: !result.success };
+            }
+            case 'pop': {
+                const result = await git.stashPop(args['index']);
+                return { success: result.success, content: result, isError: !result.success };
+            }
+            case 'list':
+            default: {
+                const stashes = await git.stashList();
+                return { success: true, content: { count: stashes.length, stashes } };
+            }
+        }
+    }
+    // ==================== Getting Started Handler ====================
+    async handleGetStarted() {
+        const workspace = this.workspaceRoot || (0, loader_js_1.findALWorkspace)();
+        const hasWorkspace = !!workspace;
+        // Check AL Language Server status
+        const alServerReady = this.alServer !== null;
+        // Get cloud status
+        let cloudConnected = false;
+        if (this.cloudClient) {
+            try {
+                cloudConnected = await this.cloudClient.checkConnection();
+            }
+            catch {
+                cloudConnected = false;
+            }
+        }
+        // Build the getting started response
+        const response = {
+            welcome: '🚀 PartnerCore AL Development - Ready to help!',
+            status: {
+                workspace: hasWorkspace ? `✅ ${workspace}` : '⚠️ No AL workspace detected (looking for app.json)',
+                alLanguageServer: alServerReady ? '✅ Ready' : '⚠️ Will initialize on first AL file operation',
+                cloudConnection: cloudConnected ? '✅ Connected (AI review, KB, templates available)' : '⚠️ Offline (local tools only)',
+            },
+            workflows: {
+                newObject: [
+                    '1. partnercore_kb_search → Find best practices',
+                    '2. partnercore_template → Get code template',
+                    '3. write_file → Write the AL code',
+                    '4. al_get_diagnostics → Check compilation (ALWAYS!)',
+                    '5. partnercore_review → Code review',
+                    '6. git_commit → Save your work',
+                ],
+                codeReview: [
+                    '1. read_file → Read the code',
+                    '2. al_get_diagnostics → Check errors',
+                    '3. partnercore_review → Get AI review',
+                    '4. al_code_actions → Get suggested fixes',
+                    '5. write_file → Apply improvements',
+                ],
+                bcContainer: [
+                    '1. bc_list_containers → Check containers',
+                    '2. bc_compile → Compile app',
+                    '3. bc_publish → Deploy to container',
+                    '4. bc_run_tests → Run tests',
+                ],
+                git: [
+                    '1. git_status → See changes',
+                    '2. git_diff → Review changes',
+                    '3. git_stage → Stage files',
+                    '4. git_commit → Commit',
+                    '5. git_push → Push to remote',
+                ],
+                refactoring: [
+                    '1. al_get_symbols → Understand structure',
+                    '2. al_find_references → Find usages',
+                    '3. al_rename_symbol → Rename',
+                    '4. al_format → Clean up',
+                    '5. al_get_diagnostics → Verify',
+                ],
+            },
+            tools: {
+                fileOperations: [
+                    'read_file - Read file contents',
+                    'write_file - Write/create files',
+                    'list_files - List directory contents',
+                    'search_files - Search text in files',
+                    'find_file - Find files by pattern',
+                    'replace_content - Search/replace with regex',
+                    'delete_lines - Delete line range',
+                    'replace_lines - Replace line range',
+                    'insert_at_line - Insert at specific line',
+                ],
+                alLanguageServer: [
+                    'al_get_diagnostics - ⭐ ALWAYS USE after writing AL code',
+                    'al_get_symbols - Get all symbols in a file',
+                    'al_find_symbol - Search symbols by name',
+                    'al_find_references - Find all references to a symbol',
+                    'al_go_to_definition - Navigate to symbol definition',
+                    'al_hover - Get type info and documentation',
+                    'al_completion - Get code completion suggestions',
+                    'al_code_actions - Get quick fixes and refactorings',
+                    'al_signature_help - Get function parameter hints',
+                    'al_format - Format document',
+                    'al_rename_symbol - Rename across workspace',
+                ],
+                bcContainers: [
+                    'bc_list_containers - List BC Docker containers',
+                    'bc_create_container - Create new container',
+                    'bc_remove_container - Remove container',
+                    'bc_compile - Compile AL project',
+                    'bc_publish - Publish app to container',
+                    'bc_run_tests - Run automated tests',
+                    'bc_download_symbols - Download symbol files',
+                ],
+                git: [
+                    'git_status - Get current status',
+                    'git_diff - Show changes',
+                    'git_stage - Stage files',
+                    'git_commit - Commit changes',
+                    'git_push - Push to remote',
+                    'git_branches - List branches',
+                    'git_checkout - Switch/create branches',
+                ],
+                projectMemory: [
+                    'write_memory - Save project knowledge for future sessions',
+                    'read_memory - Retrieve saved memory',
+                    'list_memories - List all memories',
+                    'delete_memory - Delete a memory',
+                ],
+                cloud: cloudConnected ? [
+                    'partnercore_kb_search - Search knowledge base',
+                    'partnercore_template - Get code templates',
+                    'partnercore_review - AI code review',
+                    'partnercore_validate - AppSource compliance check',
+                ] : ['(Not connected - set PARTNERCORE_API_KEY for cloud features)'],
+            },
+            criticalReminders: [
+                '⚠️ ALWAYS call al_get_diagnostics after writing any AL file',
+                '⚠️ Use MCP tools (read_file, list_files) instead of shell commands',
+                '⚠️ Workspace is auto-detected from app.json - no hardcoded paths needed',
+            ],
+            nextSteps: hasWorkspace
+                ? 'Use list_files to explore the project, or describe what you want to build.'
+                : 'Navigate to an AL project directory (containing app.json) to enable full functionality.',
+        };
+        return { success: true, content: response };
+    }
+    // ==================== Tool Definitions ====================
+    initLocalToolDefinitions() {
+        this.localToolDefinitions = [
+            {
+                name: 'al_get_started',
+                description: '🚀 START HERE - The recommended first tool to call in any AL development session. Returns: workspace status, AL Language Server status, cloud connection status, available workflows/prompts, tool categories, and a quick-start guide. Use this to understand what capabilities are available before beginning work.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {},
+                    required: [],
+                },
+            },
+            {
+                name: 'al_get_symbols',
+                description: 'Get all symbols (procedures, fields, variables, etc.) in an AL file',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        uri: {
+                            type: 'string',
+                            description: 'File URI (e.g., file:///C:/project/src/MyTable.Table.al)',
+                        },
+                    },
+                    required: ['uri'],
+                },
+            },
+            {
+                name: 'al_find_symbol',
+                description: 'Search for symbols by name across the workspace',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        query: {
+                            type: 'string',
+                            description: 'Symbol name to search for',
+                        },
+                    },
+                    required: ['query'],
+                },
+            },
+            {
+                name: 'al_find_references',
+                description: 'Find all references to a symbol at a specific position',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        uri: { type: 'string', description: 'File URI' },
+                        line: { type: 'number', description: 'Line number (0-based)' },
+                        character: { type: 'number', description: 'Character position (0-based)' },
+                    },
+                    required: ['uri', 'line', 'character'],
+                },
+            },
+            {
+                name: 'al_get_diagnostics',
+                description: 'Get compiler diagnostics (errors, warnings) for an AL file',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        uri: { type: 'string', description: 'File URI' },
+                    },
+                    required: ['uri'],
+                },
+            },
+            {
+                name: 'al_go_to_definition',
+                description: 'Go to the definition of a symbol at a specific position',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        uri: { type: 'string', description: 'File URI' },
+                        line: { type: 'number', description: 'Line number (0-based)' },
+                        character: { type: 'number', description: 'Character position (0-based)' },
+                    },
+                    required: ['uri', 'line', 'character'],
+                },
+            },
+            {
+                name: 'al_hover',
+                description: 'Get hover information (type info, documentation) for a position',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        uri: { type: 'string', description: 'File URI' },
+                        line: { type: 'number', description: 'Line number (0-based)' },
+                        character: { type: 'number', description: 'Character position (0-based)' },
+                    },
+                    required: ['uri', 'line', 'character'],
+                },
+            },
+            {
+                name: 'al_completion',
+                description: 'Get code completion suggestions at a position',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        uri: { type: 'string', description: 'File URI' },
+                        line: { type: 'number', description: 'Line number (0-based)' },
+                        character: { type: 'number', description: 'Character position (0-based)' },
+                    },
+                    required: ['uri', 'line', 'character'],
+                },
+            },
+            // ==================== New LSP Tools ====================
+            {
+                name: 'al_code_actions',
+                description: 'Get code actions (quick fixes, refactorings) for a position or range. Returns available fixes for diagnostics and refactoring options.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        uri: { type: 'string', description: 'File URI' },
+                        line: { type: 'number', description: 'Line number (0-based) for point query' },
+                        character: { type: 'number', description: 'Character position (0-based) for point query' },
+                        startLine: { type: 'number', description: 'Start line for range query' },
+                        startCharacter: { type: 'number', description: 'Start character for range query' },
+                        endLine: { type: 'number', description: 'End line for range query' },
+                        endCharacter: { type: 'number', description: 'End character for range query' },
+                        only: {
+                            type: 'array',
+                            items: { type: 'string' },
+                            description: 'Filter actions by kind (e.g., "quickfix", "refactor")'
+                        },
+                        includeDiagnostics: { type: 'boolean', description: 'Include diagnostics in context (default: true)' },
+                    },
+                    required: ['uri'],
+                },
+            },
+            {
+                name: 'al_signature_help',
+                description: 'Get signature help (function parameter hints) at a position. Useful when cursor is inside function call parentheses.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        uri: { type: 'string', description: 'File URI' },
+                        line: { type: 'number', description: 'Line number (0-based)' },
+                        character: { type: 'number', description: 'Character position (0-based), typically after "(" or ","' },
+                    },
+                    required: ['uri', 'line', 'character'],
+                },
+            },
+            {
+                name: 'al_format',
+                description: 'Format an AL document or a range within it. Can preview or apply formatting changes.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        uri: { type: 'string', description: 'File URI' },
+                        startLine: { type: 'number', description: 'Start line for range formatting (omit for full document)' },
+                        startCharacter: { type: 'number', description: 'Start character for range formatting' },
+                        endLine: { type: 'number', description: 'End line for range formatting' },
+                        endCharacter: { type: 'number', description: 'End character for range formatting' },
+                        tabSize: { type: 'number', description: 'Tab size (default: 4)' },
+                        insertSpaces: { type: 'boolean', description: 'Use spaces instead of tabs (default: true)' },
+                        apply: { type: 'boolean', description: 'Apply changes to file (default: false, preview only)' },
+                    },
+                    required: ['uri'],
+                },
+            },
+            // ==================== Additional LSP Tools (Complete Coverage) ====================
+            {
+                name: 'al_document_highlight',
+                description: 'Highlight all occurrences of the symbol under cursor. Useful for seeing where a variable/function is used.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        uri: { type: 'string', description: 'File URI' },
+                        line: { type: 'number', description: 'Line number (0-based)' },
+                        character: { type: 'number', description: 'Character position (0-based)' },
+                    },
+                    required: ['uri', 'line', 'character'],
+                },
+            },
+            {
+                name: 'al_folding_ranges',
+                description: 'Get code folding ranges (regions, procedures, comments). Useful for understanding document structure.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        uri: { type: 'string', description: 'File URI' },
+                    },
+                    required: ['uri'],
+                },
+            },
+            {
+                name: 'al_selection_range',
+                description: 'Get smart selection ranges for expanding/shrinking selection. Returns nested ranges from inner to outer.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        uri: { type: 'string', description: 'File URI' },
+                        positions: {
+                            type: 'array',
+                            items: {
+                                type: 'object',
+                                properties: {
+                                    line: { type: 'number' },
+                                    character: { type: 'number' },
+                                },
+                            },
+                            description: 'Positions to get selection ranges for'
+                        },
+                    },
+                    required: ['uri', 'positions'],
+                },
+            },
+            {
+                name: 'al_type_definition',
+                description: 'Go to the type definition of a variable. E.g., for "var x: Customer", goes to Customer table.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        uri: { type: 'string', description: 'File URI' },
+                        line: { type: 'number', description: 'Line number (0-based)' },
+                        character: { type: 'number', description: 'Character position (0-based)' },
+                    },
+                    required: ['uri', 'line', 'character'],
+                },
+            },
+            {
+                name: 'al_implementation',
+                description: 'Find implementations of an interface or abstract method.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        uri: { type: 'string', description: 'File URI' },
+                        line: { type: 'number', description: 'Line number (0-based)' },
+                        character: { type: 'number', description: 'Character position (0-based)' },
+                    },
+                    required: ['uri', 'line', 'character'],
+                },
+            },
+            {
+                name: 'al_format_on_type',
+                description: 'Format code after typing a specific character (e.g., semicolon, closing brace).',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        uri: { type: 'string', description: 'File URI' },
+                        line: { type: 'number', description: 'Line number (0-based)' },
+                        character: { type: 'number', description: 'Character position (0-based)' },
+                        ch: { type: 'string', description: 'Character that was typed (e.g., ";", "}")' },
+                        tabSize: { type: 'number', description: 'Tab size (default: 4)' },
+                        insertSpaces: { type: 'boolean', description: 'Use spaces instead of tabs (default: true)' },
+                    },
+                    required: ['uri', 'line', 'character', 'ch'],
+                },
+            },
+            {
+                name: 'al_code_lens',
+                description: 'Get code lenses (inline hints like reference counts, run test buttons).',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        uri: { type: 'string', description: 'File URI' },
+                        resolve: { type: 'boolean', description: 'Resolve lens commands (default: false)' },
+                    },
+                    required: ['uri'],
+                },
+            },
+            {
+                name: 'al_document_links',
+                description: 'Get clickable document links (URLs in comments, file references).',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        uri: { type: 'string', description: 'File URI' },
+                    },
+                    required: ['uri'],
+                },
+            },
+            {
+                name: 'al_execute_command',
+                description: 'Execute an LSP command (from code actions or code lenses).',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        command: { type: 'string', description: 'Command identifier' },
+                        arguments: {
+                            type: 'array',
+                            items: {},
+                            description: 'Command arguments'
+                        },
+                    },
+                    required: ['command'],
+                },
+            },
+            {
+                name: 'al_semantic_tokens',
+                description: 'Get semantic tokens for syntax highlighting. Returns token types and modifiers.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        uri: { type: 'string', description: 'File URI' },
+                        startLine: { type: 'number', description: 'Start line for range (omit for full document)' },
+                        startCharacter: { type: 'number', description: 'Start character for range' },
+                        endLine: { type: 'number', description: 'End line for range' },
+                        endCharacter: { type: 'number', description: 'End character for range' },
+                    },
+                    required: ['uri'],
+                },
+            },
+            {
+                name: 'al_close_document',
+                description: 'Close a document in the language server (cleanup resources).',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        uri: { type: 'string', description: 'File URI to close' },
+                    },
+                    required: ['uri'],
+                },
+            },
+            {
+                name: 'al_save_document',
+                description: 'Send save notification to language server (may trigger recompilation).',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        uri: { type: 'string', description: 'File URI' },
+                        text: { type: 'string', description: 'Optional: current file content' },
+                    },
+                    required: ['uri'],
+                },
+            },
+            // ==================== Extended AL Tools ====================
+            {
+                name: 'al_restart_server',
+                description: 'Restart the AL Language Server. Use when the server hangs or after external changes.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {},
+                    required: [],
+                },
+            },
+            {
+                name: 'al_find_referencing_symbols',
+                description: 'Find all symbols that reference the symbol at a position. Returns context around each reference.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        uri: { type: 'string', description: 'File URI' },
+                        line: { type: 'number', description: 'Line number (0-based)' },
+                        character: { type: 'number', description: 'Character position (0-based)' },
+                        includeDeclaration: { type: 'boolean', description: 'Include the declaration itself (default: false)' },
+                        contextLinesBefore: { type: 'number', description: 'Lines of context before reference (default: 1)' },
+                        contextLinesAfter: { type: 'number', description: 'Lines of context after reference (default: 1)' },
+                    },
+                    required: ['uri', 'line', 'character'],
+                },
+            },
+            {
+                name: 'al_insert_before_symbol',
+                description: 'Insert content before a named symbol (e.g., add import, decorator, or method before a class).',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        uri: { type: 'string', description: 'File URI' },
+                        symbolName: { type: 'string', description: 'Name of the symbol to insert before' },
+                        content: { type: 'string', description: 'Content to insert' },
+                    },
+                    required: ['uri', 'symbolName', 'content'],
+                },
+            },
+            {
+                name: 'find_file',
+                description: 'Find files matching a pattern (supports * and ? wildcards).',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        pattern: { type: 'string', description: 'File pattern to match (e.g., "*.Table.al", "Customer*")' },
+                        directory: { type: 'string', description: 'Directory to search in (default: workspace root)' },
+                    },
+                    required: ['pattern'],
+                },
+            },
+            {
+                name: 'replace_content',
+                description: 'Replace content in a file using literal string or regex. Powerful for multi-line edits.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        path: { type: 'string', description: 'File path' },
+                        needle: { type: 'string', description: 'String or regex pattern to find' },
+                        replacement: { type: 'string', description: 'Replacement text' },
+                        mode: { type: 'string', enum: ['literal', 'regex'], description: 'Match mode (default: literal)' },
+                        allowMultiple: { type: 'boolean', description: 'Allow replacing multiple matches (default: false)' },
+                    },
+                    required: ['path', 'needle', 'replacement'],
+                },
+            },
+            {
+                name: 'edit_memory',
+                description: 'Edit a memory using search/replace (supports regex).',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        name: { type: 'string', description: 'Memory name' },
+                        needle: { type: 'string', description: 'String or regex pattern to find' },
+                        replacement: { type: 'string', description: 'Replacement text' },
+                        mode: { type: 'string', enum: ['literal', 'regex'], description: 'Match mode (default: literal)' },
+                        allowMultiple: { type: 'boolean', description: 'Allow replacing multiple matches (default: false)' },
+                    },
+                    required: ['name', 'needle', 'replacement'],
+                },
+            },
+            {
+                name: 'read_file',
+                description: 'Read the contents of a file',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        path: { type: 'string', description: 'File path' },
+                    },
+                    required: ['path'],
+                },
+            },
+            {
+                name: 'write_file',
+                description: 'Write content to a file',
                 inputSchema: {
                     type: 'object',
                     properties: {
-                        uri: {
-                            type: 'string',
-                            description: 'File URI (e.g., file:///C:/project/src/MyTable.Table.al)',
-                        },
+                        path: { type: 'string', description: 'File path' },
+                        content: { type: 'string', description: 'File content' },
                     },
-                    required: ['uri'],
+                    required: ['path', 'content'],
                 },
             },
             {
-                name: 'al_find_symbol',
-                description: 'Search for symbols by name across the workspace',
+                name: 'list_files',
+                description: 'List files in a directory',
                 inputSchema: {
                     type: 'object',
                     properties: {
-                        query: {
-                            type: 'string',
-                            description: 'Symbol name to search for',
-                        },
+                        path: { type: 'string', description: 'Directory path' },
+                        pattern: { type: 'string', description: 'File pattern (e.g., *.al)' },
                     },
-                    required: ['query'],
+                    required: ['path'],
                 },
             },
             {
-                name: 'al_find_references',
-                description: 'Find all references to a symbol at a specific position',
+                name: 'search_files',
+                description: 'Search for text in files',
                 inputSchema: {
                     type: 'object',
                     properties: {
-                        uri: { type: 'string', description: 'File URI' },
-                        line: { type: 'number', description: 'Line number (0-based)' },
-                        character: { type: 'number', description: 'Character position (0-based)' },
+                        path: { type: 'string', description: 'Directory path' },
+                        query: { type: 'string', description: 'Search query' },
+                        filePattern: { type: 'string', description: 'File pattern (default: *.al)' },
                     },
-                    required: ['uri', 'line', 'character'],
+                    required: ['path', 'query'],
                 },
             },
+            // ==================== Symbol-Based Editing Tools ====================
             {
-                name: 'al_get_diagnostics',
-                description: 'Get compiler diagnostics (errors, warnings) for an AL file',
+                name: 'al_rename_symbol',
+                description: 'Rename a symbol (variable, procedure, field, etc.) across the entire workspace. Uses LSP refactoring capabilities for accurate renaming.',
                 inputSchema: {
                     type: 'object',
                     properties: {
-                        uri: { type: 'string', description: 'File URI' },
+                        uri: { type: 'string', description: 'File URI where the symbol is defined' },
+                        line: { type: 'number', description: 'Line number of the symbol (0-based)' },
+                        character: { type: 'number', description: 'Character position of the symbol (0-based)' },
+                        newName: { type: 'string', description: 'The new name for the symbol' },
                     },
-                    required: ['uri'],
+                    required: ['uri', 'line', 'character', 'newName'],
                 },
             },
             {
-                name: 'al_go_to_definition',
-                description: 'Go to the definition of a symbol at a specific position',
+                name: 'al_insert_after_symbol',
+                description: 'Insert content after a named symbol (procedure, field, etc.). Useful for adding new procedures or fields after existing ones.',
                 inputSchema: {
                     type: 'object',
                     properties: {
                         uri: { type: 'string', description: 'File URI' },
-                        line: { type: 'number', description: 'Line number (0-based)' },
-                        character: { type: 'number', description: 'Character position (0-based)' },
+                        symbolName: { type: 'string', description: 'Name of the symbol to insert after' },
+                        content: { type: 'string', description: 'Content to insert' },
                     },
-                    required: ['uri', 'line', 'character'],
+                    required: ['uri', 'symbolName', 'content'],
                 },
             },
             {
-                name: 'al_hover',
-                description: 'Get hover information (type info, documentation) for a position',
+                name: 'al_replace_symbol_body',
+                description: 'Replace the entire body of a symbol (procedure body, trigger body, etc.). Useful for rewriting implementations.',
                 inputSchema: {
                     type: 'object',
                     properties: {
                         uri: { type: 'string', description: 'File URI' },
-                        line: { type: 'number', description: 'Line number (0-based)' },
-                        character: { type: 'number', description: 'Character position (0-based)' },
+                        symbolName: { type: 'string', description: 'Name of the symbol to replace' },
+                        newBody: { type: 'string', description: 'New body content for the symbol' },
                     },
-                    required: ['uri', 'line', 'character'],
+                    required: ['uri', 'symbolName', 'newBody'],
                 },
             },
+            // ==================== Advanced File Operations ====================
             {
-                name: 'al_completion',
-                description: 'Get code completion suggestions at a position',
+                name: 'delete_lines',
+                description: 'Delete a range of lines from a file. Line numbers are 1-based.',
                 inputSchema: {
                     type: 'object',
                     properties: {
-                        uri: { type: 'string', description: 'File URI' },
-                        line: { type: 'number', description: 'Line number (0-based)' },
-                        character: { type: 'number', description: 'Character position (0-based)' },
+                        path: { type: 'string', description: 'File path' },
+                        startLine: { type: 'number', description: 'First line to delete (1-based)' },
+                        endLine: { type: 'number', description: 'Last line to delete (1-based, inclusive)' },
                     },
-                    required: ['uri', 'line', 'character'],
+                    required: ['path', 'startLine', 'endLine'],
                 },
             },
             {
-                name: 'read_file',
-                description: 'Read the contents of a file',
+                name: 'replace_lines',
+                description: 'Replace a range of lines in a file with new content. Line numbers are 1-based.',
                 inputSchema: {
                     type: 'object',
                     properties: {
                         path: { type: 'string', description: 'File path' },
+                        startLine: { type: 'number', description: 'First line to replace (1-based)' },
+                        endLine: { type: 'number', description: 'Last line to replace (1-based, inclusive)' },
+                        newContent: { type: 'string', description: 'New content to insert (can be multi-line)' },
                     },
-                    required: ['path'],
+                    required: ['path', 'startLine', 'endLine', 'newContent'],
                 },
             },
             {
-                name: 'write_file',
-                description: 'Write content to a file',
+                name: 'insert_at_line',
+                description: 'Insert content at a specific line number. Existing content is pushed down. Line number is 1-based.',
                 inputSchema: {
                     type: 'object',
                     properties: {
                         path: { type: 'string', description: 'File path' },
-                        content: { type: 'string', description: 'File content' },
+                        line: { type: 'number', description: 'Line number to insert at (1-based)' },
+                        content: { type: 'string', description: 'Content to insert (can be multi-line)' },
                     },
-                    required: ['path', 'content'],
+                    required: ['path', 'line', 'content'],
                 },
             },
+            // ==================== Project Memory Tools ====================
             {
-                name: 'list_files',
-                description: 'List files in a directory',
+                name: 'write_memory',
+                description: 'Save project-specific knowledge/memory for future reference. Memories persist across sessions and can be used to maintain context about the project.',
                 inputSchema: {
                     type: 'object',
                     properties: {
-                        path: { type: 'string', description: 'Directory path' },
-                        pattern: { type: 'string', description: 'File pattern (e.g., *.al)' },
+                        name: { type: 'string', description: 'Memory name (unique identifier)' },
+                        content: { type: 'string', description: 'Memory content (markdown supported)' },
+                        tags: {
+                            type: 'array',
+                            items: { type: 'string' },
+                            description: 'Optional tags for categorization'
+                        },
                     },
-                    required: ['path'],
+                    required: ['name', 'content'],
                 },
             },
             {
-                name: 'search_files',
-                description: 'Search for text in files',
+                name: 'read_memory',
+                description: 'Read a specific memory by name. Use list_memories first to see available memories.',
                 inputSchema: {
                     type: 'object',
                     properties: {
-                        path: { type: 'string', description: 'Directory path' },
-                        query: { type: 'string', description: 'Search query' },
-                        filePattern: { type: 'string', description: 'File pattern (default: *.al)' },
+                        name: { type: 'string', description: 'Memory name to read' },
                     },
-                    required: ['path', 'query'],
+                    required: ['name'],
+                },
+            },
+            {
+                name: 'list_memories',
+                description: 'List all saved project memories. Returns names, timestamps, tags, and content previews.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {},
+                    required: [],
+                },
+            },
+            {
+                name: 'delete_memory',
+                description: 'Delete a specific memory by name.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        name: { type: 'string', description: 'Memory name to delete' },
+                    },
+                    required: ['name'],
+                },
+            },
+            // ==================== BC Container Tools ====================
+            {
+                name: 'bc_list_containers',
+                description: 'List all Business Central Docker containers. Shows container name, image, status, and ports.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {},
+                    required: [],
+                },
+            },
+            {
+                name: 'bc_compile',
+                description: 'Compile the AL project in a BC container. Runs all CodeCops (AppSource, UI, PerTenant). Returns app file path, errors, and warnings.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        containerName: { type: 'string', description: 'Name of the BC container' },
+                        appProjectFolder: { type: 'string', description: 'Path to AL project folder (default: workspace root)' },
+                        outputFolder: { type: 'string', description: 'Path for output .app file (default: .output)' },
+                    },
+                    required: ['containerName'],
+                },
+            },
+            {
+                name: 'bc_publish',
+                description: 'Publish an AL app to a BC container. Automatically finds the latest compiled .app file or uses specified path.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        containerName: { type: 'string', description: 'Name of the BC container' },
+                        appFile: { type: 'string', description: 'Path to .app file (default: latest in .output)' },
+                        syncMode: {
+                            type: 'string',
+                            enum: ['Add', 'Clean', 'Development', 'ForceSync'],
+                            description: 'Sync mode for schema changes (default: Development)'
+                        },
+                        skipVerification: { type: 'boolean', description: 'Skip code signing verification' },
+                        install: { type: 'boolean', description: 'Install the app after publishing' },
+                    },
+                    required: ['containerName'],
+                },
+            },
+            {
+                name: 'bc_run_tests',
+                description: 'Run automated tests in a BC container. Can run all tests, specific codeunit, or specific test function.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        containerName: { type: 'string', description: 'Name of the BC container' },
+                        testCodeunit: { type: 'number', description: 'Specific test codeunit ID to run' },
+                        testFunction: { type: 'string', description: 'Specific test function name to run' },
+                        extensionId: { type: 'string', description: 'Extension ID to filter tests' },
+                        detailed: { type: 'boolean', description: 'Return detailed test results' },
+                    },
+                    required: ['containerName'],
+                },
+            },
+            {
+                name: 'bc_container_logs',
+                description: 'Get logs from a BC container. Useful for debugging startup or runtime issues.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        containerName: { type: 'string', description: 'Name of the BC container' },
+                        tail: { type: 'number', description: 'Number of lines from end (default: all)' },
+                        since: { type: 'string', description: 'Show logs since timestamp (e.g., "2h", "30m")' },
+                    },
+                    required: ['containerName'],
+                },
+            },
+            {
+                name: 'bc_start_container',
+                description: 'Start a stopped BC container.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        containerName: { type: 'string', description: 'Name of the BC container' },
+                    },
+                    required: ['containerName'],
+                },
+            },
+            {
+                name: 'bc_stop_container',
+                description: 'Stop a running BC container.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        containerName: { type: 'string', description: 'Name of the BC container' },
+                    },
+                    required: ['containerName'],
+                },
+            },
+            {
+                name: 'bc_restart_container',
+                description: 'Restart a BC container.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        containerName: { type: 'string', description: 'Name of the BC container' },
+                    },
+                    required: ['containerName'],
+                },
+            },
+            {
+                name: 'bc_download_symbols',
+                description: 'Download symbol files (.app) from a BC container. Required for code completion and compilation.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        containerName: { type: 'string', description: 'Name of the BC container' },
+                        targetFolder: { type: 'string', description: 'Target folder for symbols (default: .alpackages)' },
+                    },
+                    required: ['containerName'],
+                },
+            },
+            {
+                name: 'bc_create_container',
+                description: 'Create a new Business Central Docker container using BcContainerHelper. Takes ~10-30 minutes.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        containerName: { type: 'string', description: 'Name for the new container' },
+                        version: { type: 'string', description: 'BC version (e.g., "23.0", "24.1"). Default: latest' },
+                        country: { type: 'string', description: 'Country/region (e.g., "us", "w1", "de"). Default: us' },
+                        type: { type: 'string', enum: ['Sandbox', 'OnPrem'], description: 'Container type. Default: Sandbox' },
+                        auth: { type: 'string', enum: ['UserPassword', 'NavUserPassword', 'Windows', 'AAD'], description: 'Authentication type' },
+                        username: { type: 'string', description: 'Admin username (with auth)' },
+                        password: { type: 'string', description: 'Admin password (with auth)' },
+                        artifactUrl: { type: 'string', description: 'Direct artifact URL (overrides version/country/type)' },
+                        licenseFile: { type: 'string', description: 'Path to license file' },
+                        accept_eula: { type: 'boolean', description: 'Accept EULA (default: true)' },
+                        accept_outdated: { type: 'boolean', description: 'Accept outdated images' },
+                        includeTestToolkit: { type: 'boolean', description: 'Include test toolkit' },
+                        includeTestLibrariesOnly: { type: 'boolean', description: 'Include only test libraries' },
+                        includeTestFrameworkOnly: { type: 'boolean', description: 'Include only test framework' },
+                        enableTaskScheduler: { type: 'boolean', description: 'Enable task scheduler' },
+                        assignPremiumPlan: { type: 'boolean', description: 'Assign premium plan to admin' },
+                        multitenant: { type: 'boolean', description: 'Create multitenant container' },
+                        memoryLimit: { type: 'string', description: 'Memory limit (e.g., "8G")' },
+                        isolation: { type: 'string', enum: ['hyperv', 'process'], description: 'Container isolation mode' },
+                        updateHosts: { type: 'boolean', description: 'Update hosts file with container name' },
+                    },
+                    required: ['containerName'],
+                },
+            },
+            {
+                name: 'bc_remove_container',
+                description: 'Remove a Business Central Docker container and clean up resources.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        containerName: { type: 'string', description: 'Name of the container to remove' },
+                        force: { type: 'boolean', description: 'Force remove even if running (default: false)' },
+                    },
+                    required: ['containerName'],
+                },
+            },
+            {
+                name: 'bc_get_extensions',
+                description: 'List all installed extensions/apps in a BC container.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        containerName: { type: 'string', description: 'Name of the BC container' },
+                    },
+                    required: ['containerName'],
+                },
+            },
+            {
+                name: 'bc_uninstall_app',
+                description: 'Uninstall an app from a BC container.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        containerName: { type: 'string', description: 'Name of the BC container' },
+                        name: { type: 'string', description: 'Name of the app to uninstall' },
+                        publisher: { type: 'string', description: 'Publisher of the app (optional)' },
+                        version: { type: 'string', description: 'Version of the app (optional)' },
+                        force: { type: 'boolean', description: 'Force uninstall (default: false)' },
+                        username: { type: 'string', description: 'Admin username (optional)' },
+                        password: { type: 'string', description: 'Admin password (optional)' },
+                    },
+                    required: ['containerName', 'name'],
+                },
+            },
+            {
+                name: 'bc_compile_warnings',
+                description: 'Compile AL project and return only warnings (quick check without full build output).',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        containerName: { type: 'string', description: 'Name of the BC container' },
+                        appProjectFolder: { type: 'string', description: 'Path to app project folder (default: workspace root)' },
+                    },
+                    required: ['containerName'],
+                },
+            },
+            // ==================== Git Tools ====================
+            {
+                name: 'git_status',
+                description: 'Get current Git status including branch, staged/modified/untracked files, and ahead/behind counts.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {},
+                    required: [],
+                },
+            },
+            {
+                name: 'git_diff',
+                description: 'Show Git diff of changes. Can show all changes, staged changes, or changes to a specific file.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        staged: { type: 'boolean', description: 'Show only staged changes' },
+                        file: { type: 'string', description: 'Show diff for a specific file' },
+                        unified: { type: 'number', description: 'Number of context lines' },
+                    },
+                    required: [],
+                },
+            },
+            {
+                name: 'git_stage',
+                description: 'Stage files for commit. Use "all" to stage all changes.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        paths: {
+                            oneOf: [
+                                { type: 'array', items: { type: 'string' } },
+                                { type: 'string', enum: ['all'] }
+                            ],
+                            description: 'Files to stage, or "all" for all changes'
+                        },
+                    },
+                    required: ['paths'],
+                },
+            },
+            {
+                name: 'git_commit',
+                description: 'Commit staged changes with a message.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        message: { type: 'string', description: 'Commit message' },
+                        amend: { type: 'boolean', description: 'Amend the previous commit' },
+                        allowEmpty: { type: 'boolean', description: 'Allow empty commit' },
+                    },
+                    required: ['message'],
+                },
+            },
+            {
+                name: 'git_log',
+                description: 'Show commit history with filtering options.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        limit: { type: 'number', description: 'Number of commits (default: 20)' },
+                        since: { type: 'string', description: 'Show commits since date (e.g., "2 weeks ago")' },
+                        author: { type: 'string', description: 'Filter by author name/email' },
+                        grep: { type: 'string', description: 'Search commit messages' },
+                        file: { type: 'string', description: 'Show commits for a specific file' },
+                    },
+                    required: [],
+                },
+            },
+            {
+                name: 'git_branches',
+                description: 'List Git branches. Shows current branch, tracking info, and upstream.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        remote: { type: 'boolean', description: 'List remote branches instead of local' },
+                    },
+                    required: [],
+                },
+            },
+            {
+                name: 'git_checkout',
+                description: 'Switch to a branch or create a new branch.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        target: { type: 'string', description: 'Branch name to switch to' },
+                        create: { type: 'boolean', description: 'Create new branch (-b flag)' },
+                    },
+                    required: ['target'],
+                },
+            },
+            {
+                name: 'git_pull',
+                description: 'Pull changes from remote repository.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        remote: { type: 'string', description: 'Remote name (default: origin)' },
+                        branch: { type: 'string', description: 'Branch to pull' },
+                        rebase: { type: 'boolean', description: 'Rebase instead of merge' },
+                    },
+                    required: [],
+                },
+            },
+            {
+                name: 'git_push',
+                description: 'Push commits to remote repository.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        remote: { type: 'string', description: 'Remote name (default: origin)' },
+                        branch: { type: 'string', description: 'Branch to push' },
+                        setUpstream: { type: 'boolean', description: 'Set upstream (-u flag)' },
+                        force: { type: 'boolean', description: 'Force push with lease' },
+                    },
+                    required: [],
+                },
+            },
+            {
+                name: 'git_stash',
+                description: 'Manage Git stashes (save, pop, list).',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        action: {
+                            type: 'string',
+                            enum: ['save', 'push', 'pop', 'list'],
+                            description: 'Action to perform (default: list)'
+                        },
+                        message: { type: 'string', description: 'Stash message (for save/push)' },
+                        includeUntracked: { type: 'boolean', description: 'Include untracked files (for save/push)' },
+                        index: { type: 'number', description: 'Stash index (for pop)' },
+                    },
+                    required: [],
                 },
             },
         ];