@mrxkun/mcfast-mcp 3.1.0 → 3.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mrxkun/mcfast-mcp",
-  "version": "3.1.0",
+  "version": "3.2.0",
   "description": "Ultra-fast code editing with fuzzy patching, auto-rollback, and 5 unified tools.",
   "type": "module",
   "bin": {
@@ -34,9 +34,14 @@
     "@modelcontextprotocol/sdk": "^0.6.0",
     "fast-glob": "^3.3.3",
     "ignore": "^7.0.5",
+    "tree-sitter-c-sharp": "^0.23.1",
+    "tree-sitter-cpp": "^0.23.4",
     "tree-sitter-go": "^0.25.0",
     "tree-sitter-java": "^0.23.5",
     "tree-sitter-javascript": "^0.25.0",
+    "tree-sitter-php": "^0.24.2",
+    "tree-sitter-python": "^0.25.0",
+    "tree-sitter-ruby": "^0.23.1",
     "tree-sitter-rust": "^0.24.0",
     "web-tree-sitter": "^0.26.5"
   }

package/src/index.js

@@ -30,7 +30,14 @@ import {
 } from './strategies/multi-file-coordinator.js';
 import { detectLanguage, validateSyntax } from './strategies/syntax-validator.js';
 import { validate as validateTreeSitter } from './strategies/tree-sitter/index.js';
-import { renameSymbol as renameSymbolTreeSitter } from './strategies/tree-sitter/refactor.js';
+import {
+    renameSymbol as renameSymbolTreeSitter,
+    findDefinition,
+    findReferences,
+    organizeImports,
+    extractFunction,
+    moveCode
+} from './strategies/tree-sitter/refactor.js';
 import { safeEdit } from './utils/backup.js';
 import { formatError } from './utils/error-formatter.js';
 
@@ -71,6 +78,8 @@ const toolIcons = {
     list_files_fast: '📁',
     edit_file: '✏️',
     read_file: '📖',
+    get_definition: '🔗',
+    find_references: '📑',
 };
 
 // Backward compatibility mapping
@@ -82,7 +91,8 @@ const TOOL_ALIASES = {
     'search_code_ai': 'search',
     'search_filesystem': 'search',
     'list_files_fast': 'list_files',
-    'read_file': 'read'
+    'read_file': 'read',
+    'goto_definition': 'get_definition' // alias
 };
 
 /**
@@ -193,13 +203,13 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
             // CORE TOOL 1: edit (consolidates apply_fast + edit_file + apply_search_replace)
             {
                 name: "edit",
-                description: "**PRIMARY TOOL FOR EDITING FILES** - Intelligently edits files with automatic strategy detection. Consolidates apply_fast, edit_file, and apply_search_replace into one smart tool. Supports: (1) Simple search/replace, (2) Placeholder-based editing with '// ... existing code ...', (3) Complex multi-file refactoring via Mercury AI.",
+                description: "**PRIMARY TOOL FOR EDITING FILES** - Intelligent auto-switching strategies: (1) Search & Replace (Fastest) - use 'Replace X with Y', (2) Placeholder (Efficient) - use '// ... existing code ...', (3) Mercury AI (Intelligent) - for complex refactoring. Includes Auto-Rollback for syntax errors.",
                 inputSchema: {
                     type: "object",
                     properties: {
                         instruction: {
                             type: "string",
-                            description: "Natural language instruction describing changes. For search/replace, use 'Replace X with Y' format."
+                            description: "Natural language instruction. For simple edits, use 'Replace <exact code> with <new code>'."
                         },
                         files: {
                             type: "object",
@@ -208,7 +218,7 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
                         },
                         code_edit: {
                             type: "string",
-                            description: "Optional: Partial code snippet with '// ... existing code ...' placeholders for token-efficient editing."
+                            description: "Optional: Code snippet. Use '// ... existing code ...' placeholders to save tokens."
                         },
                         dryRun: {
                             type: "boolean",
@@ -221,13 +231,13 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
             // CORE TOOL 2: search (consolidates search_code + search_code_ai + search_filesystem)
             {
                 name: "search",
-                description: "**UNIFIED CODE SEARCH** - Automatically selects the best search strategy: (1) Local search if files provided, (2) AI semantic search for complex queries, (3) Filesystem grep for fast codebase-wide search.",
+                description: "**UNIFIED CODE SEARCH** - Strategies: (1) Local (if files provided), (2) Filesystem grep (fast string match), (3) AI Semantic (natural language queries).",
                 inputSchema: {
                     type: "object",
                     properties: {
                         query: {
                             type: "string",
-                            description: "Search query (literal string or natural language)"
+                            description: "Search query. Use specific strings for grep, natural language for AI."
                         },
                         files: {
                             type: "object",
@@ -253,7 +263,7 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
             // CORE TOOL 3: read
             {
                 name: "read",
-                description: "Read file contents with optional line range support to save tokens. Use this before editing files or to understand code structure.",
+                description: "Read file contents. CRITICAL: Use `start_line` and `end_line` for large files to reduce token usage and latency.",
                 inputSchema: {
                     type: "object",
                     properties: {
@@ -290,6 +300,32 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
                     },
                     required: ["instruction", "files"]
                 }
+            },
+            // NEW TOOL: get_definition
+            {
+                name: "get_definition",
+                description: "Find the definition of a symbol in a file (LSP-like).",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        path: { type: "string", description: "Path to the file containing the usage" },
+                        symbol: { type: "string", description: "The symbol/identifier to find definition for" }
+                    },
+                    required: ["path", "symbol"]
+                }
+            },
+            // NEW TOOL: find_references
+            {
+                name: "find_references",
+                description: "Find all usages of a symbol across the file (and potentially others if supported).",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        path: { type: "string", description: "Path to the file containing the symbol" },
+                        symbol: { type: "string", description: "The symbol/identifier to find references for" }
+                    },
+                    required: ["path", "symbol"]
+                }
             }
         ],
     };
@@ -442,6 +478,14 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             result = await handleReapply(args);
             summary = 'Retry edit applied';
         }
+        else if (name === "get_definition") {
+            result = await handleGetDefinition(args);
+            summary = 'Definition found';
+        }
+        else if (name === "find_references") {
+            result = await handleFindReferences(args);
+            summary = 'References found';
+        }
         else {
             throw new Error(`Tool not found: ${name}`);
         }
@@ -696,10 +740,35 @@ async function handleEdit({ instruction, files, code_edit, dryRun = false }) {
                             return renameIdentifier(ast, pattern.oldName, pattern.newName);
                         });
                     }
+                } else if (pattern.type === 'extract_function') {
+                    console.error(`${colors.cyan}[TREE-SITTER]${colors.reset} Extracting function '${pattern.functionName}' from lines ${pattern.startLine}-${pattern.endLine}`);
+                    const newCode = await extractFunction(fileContent, filePath, pattern.startLine, pattern.endLine, pattern.functionName);
+                    transformResult = { success: true, code: newCode, count: 1 };
+                } else if (pattern.type === 'move_code') {
+                    console.error(`${colors.cyan}[TREE-SITTER]${colors.reset} Moving code from lines ${pattern.startLine}-${pattern.endLine} to line ${pattern.targetLine}`);
+                    const newCode = await moveCode(fileContent, filePath, pattern.startLine, pattern.endLine, pattern.targetLine);
+                    transformResult = { success: true, code: newCode, count: 1 };
                 } else if (pattern.type.startsWith('inline')) {
                     transformResult = applyASTTransformation(fileContent, filePath, (ast) => {
                         return inlineVariable(ast, pattern.oldName);
                     });
+                } else if (pattern.type === 'organize_imports') {
+                    // Supported for Tree-sitter languages (JS/TS/Go/Python/etc)
+                    const language = detectLanguage(filePath);
+                    console.error(`${colors.cyan}[TREE-SITTER]${colors.reset} Organizing imports for ${language}`);
+
+                    const newCode = await organizeImports(fileContent, filePath);
+                    // Check if anything changed
+                    if (newCode === fileContent) {
+                        return {
+                            content: [{
+                                type: "text",
+                                text: `✅ Imports already organized for ${filePath}`
+                            }]
+                        };
+                    }
+                    transformResult = { success: true, code: newCode, count: 1 };
+
                 } else {
                     throw new Error(`Unsupported refactoring type: ${pattern.type}`);
                 }
@@ -1460,6 +1529,48 @@ async function handleSearchCodeAI({ query, files, contextLines = 2 }) {
     }
 }
 
+async function handleGetDefinition({ path: filePath, symbol }) {
+    if (!filePath || !symbol) throw new Error("Missing path or symbol");
+
+    // Read file content first
+    const content = await fs.readFile(filePath, 'utf8');
+    const definitions = await findDefinition(content, filePath, symbol);
+
+    if (definitions.length === 0) {
+        return {
+            content: [{ type: "text", text: `No definition found for '${symbol}' in ${filePath}` }]
+        };
+    }
+
+    const def = definitions[0]; // Take first
+
+    return {
+        content: [{ type: "text", text: `Definition of '${symbol}':\n${filePath}:${def.line}:${def.column} (${def.type || 'unknown'})` }]
+    };
+}
+
+async function handleFindReferences({ path: filePath, symbol }) {
+    if (!filePath || !symbol) throw new Error("Missing path or symbol");
+
+    const content = await fs.readFile(filePath, 'utf8');
+    const references = await findReferences(content, filePath, symbol);
+
+    if (references.length === 0) {
+        return {
+            content: [{ type: "text", text: `No references found for '${symbol}' in ${filePath}` }]
+        };
+    }
+
+    let output = `References for '${symbol}' in ${filePath} (${references.length}):\n`;
+    references.forEach(ref => {
+        output += `${ref.line}:${ref.column}\n`;
+    });
+
+    return {
+        content: [{ type: "text", text: output }]
+    };
+}
+
 /**
  * Start Server
  */

package/src/strategies/ast-detector.js

@@ -62,14 +62,22 @@ export function detectRefactoringPattern(instruction) {
         rename_function: /rename\s+(?:function|func)\s+["`']?(\w+)["`']?\s+to\s+["`']?(\w+)["`']?/i,
         rename_class: /rename\s+class\s+["`']?(\w+)["`']?\s+to\s+["`']?(\w+)["`']?/i,
         rename_any: /rename\s+["`']?(\w+)["`']?\s+to\s+["`']?(\w+)["`']?/i,
-        extract_function: /extract\s+(?:function|method)/i,
+        extract_function: /extract\s+(?:function|method)\s+["`']?(\w+)["`']?\s+from\s+line\s+(\d+)\s+to\s+(\d+)/i,
+        move_code: /move\s+code\s+from\s+line\s+(\d+)\s+to\s+(\d+)\s+to\s+line\s+(\d+)/i,
         inline_variable: /inline\s+(?:variable|var|const|let)\s+["`']?(\w+)["`']?/i,
-        inline_function: /inline\s+(?:function|func)\s+["`']?(\w+)["`']?/i
+        inline_function: /inline\s+(?:function|func)\s+["`']?(\w+)["`']?/i,
+        organize_imports: /organize\s+imports/i
     };
 
     for (const [type, pattern] of Object.entries(patterns)) {
         const match = instruction.match(pattern);
         if (match) {
+            if (type === 'extract_function') {
+                return { type, functionName: match[1], startLine: parseInt(match[2]), endLine: parseInt(match[3]) };
+            }
+            if (type === 'move_code') {
+                return { type, startLine: parseInt(match[1]), endLine: parseInt(match[2]), targetLine: parseInt(match[3]) };
+            }
             return {
                 type,
                 oldName: match[1],

package/src/strategies/fuzzy-patch.js

@@ -134,7 +134,7 @@ export function parseDiff(diffText) {
 export function findBestMatch(targetLines, fileLines, startHint = 0) {
     let bestMatch = null;
     let bestScore = Infinity;
-    const maxIterations = 10000;
+    const maxIterations = 50000; // Increased from 10k to 50k
     let iterations = 0;
 
     const useSemanticMatching = isSemanticMatchingEnabled();
@@ -143,6 +143,10 @@ export function findBestMatch(targetLines, fileLines, startHint = 0) {
         console.error('[FUZZY] Semantic matching enabled');
     }
 
+    // optimization: pre-normalize lines to handle indentation/whitespace
+    const normTargetLines = targetLines.map(l => normalizeWhitespace(l));
+    const normFileLines = fileLines.map(l => normalizeWhitespace(l));
+
     // Try exact match first at hint location
     if (startHint >= 0 && startHint + targetLines.length <= fileLines.length) {
         const exactMatch = targetLines.every((line, i) =>
@@ -161,6 +165,21 @@ export function findBestMatch(targetLines, fileLines, startHint = 0) {
             break;
         }
 
+        // Optimization: Sampled check
+        // Check first, middle, and last line. If they are very different, skip block.
+        if (targetLines.length > 5) {
+            const indices = [0, Math.floor(targetLines.length / 2), targetLines.length - 1];
+            let sampleDist = 0;
+            for (const idx of indices) {
+                // Use normalized lines for check
+                sampleDist += levenshteinDistance(normTargetLines[idx], normFileLines[i + idx], 20); // strict limit
+            }
+            // If average distance per sample line is high (> 10 chars), skip
+            if (sampleDist > indices.length * 10) {
+                continue;
+            }
+        }
+
         let totalDistance = 0;
         let tokenSimilaritySum = 0;
         let contextMatchSum = 0;
@@ -169,8 +188,12 @@ export function findBestMatch(targetLines, fileLines, startHint = 0) {
             const targetLine = targetLines[j];
             const fileLine = fileLines[i + j];
 
-            // Levenshtein distance
-            const distance = levenshteinDistance(targetLine, fileLine);
+            // Use NORMALIZED lines for distance to ignore indentation differences
+            const nTarget = normTargetLines[j];
+            const nFile = normFileLines[i + j];
+
+            // Levenshtein distance on normalized text
+            const distance = levenshteinDistance(nTarget, nFile);
             totalDistance += distance;
 
             // Token similarity (always available)

package/src/strategies/syntax-validator.js

@@ -53,6 +53,16 @@ export function validateSyntax(code, language) {
             return validateRust(code);
         case 'java':
             return validateJava(code);
+        case 'python':
+            return validatePython(code);
+        case 'php':
+            return validatePHP(code);
+        case 'ruby':
+            return validateRuby(code);
+        case 'cpp':
+            return validateCPP(code);
+        case 'csharp':
+            return validateCSharp(code);
         default:
             return { valid: true, error: null };
     }
@@ -141,54 +151,99 @@ function checkBalancedBraces(code) {
     return { valid: true, error: null };
 }
 
+import fs from 'fs';
+import os from 'os';
 import { execSync } from 'child_process';
 
+function validateWithCommand(code, ext, commandGen) {
+    const tempFile = path.join(os.tmpdir(), `mcfast_validate_${Date.now()}${ext}`);
+    try {
+        fs.writeFileSync(tempFile, code);
+        execSync(commandGen(tempFile), { stdio: 'pipe' }); // pipe to capture stderr if needed, but execSync throws on non-zero exit
+        return { valid: true, error: null };
+    } catch (e) {
+        return {
+            valid: false,
+            error: e.stderr ? e.stderr.toString() : e.message
+        };
+    } finally {
+        try {
+            if (fs.existsSync(tempFile)) fs.unlinkSync(tempFile);
+        } catch (e) {
+            // ignore cleanup error
+        }
+    }
+}
+
 function validateGo(code) {
     // Check if `go` is installed
     try {
         execSync('go version', { stdio: 'ignore' });
     } catch {
-        // If Go is not installed, fallback to basic structure check
-        if (code.includes('func main()')) {
-            const hasPackageMain = /^\s*package\s+main\b/m.test(code);
-            if (!hasPackageMain) {
-                return { valid: false, error: 'Go files with main function must have package main' };
-            }
+        // Fallback to basic structure check
+        if (code.includes('func main()') && !/^\s*package\s+main\b/m.test(code)) {
+            return { valid: false, error: 'Go files with main function must have package main' };
         }
         return { valid: true, error: null };
     }
+    // Use `gofmt -e` on temp file
+    return validateWithCommand(code, '.go', (f) => `gofmt -e "${f}"`);
+}
 
+function validateRust(code) {
+    // `rustc --parse-only`
     try {
-        // Create temp file for validation
-        // Note: execSync specific implementation might change based on environment
-        // For simplicity in this context, we use a quick format check
-        // `gofmt -e` prints errors to stderr if syntax is invalid
-        const input = code.replace(/"/g, '\\"'); // Simple escape, in production need better temp file handling
-        // Real implementation should write to temp file, but for speed we try stdin piping if supported or just basic checks
-        // Better approach: Write to temp file is safer.
-        // Since we don't have easy temp file write here without fs, we fallback to our structural check for now 
-        // OR we can assume safeEdit calling this might handle temp files?
-        // Let's stick to the robust check:
-        // 1. We should ideally write a temp file.
-        // But safeEdit already writes to the actual file! 
-        // Wait, safeEdit writes to the actual file, then calls this validator?
-        // No, safeEdit writes, then validates. So the file exists on disk!
-        // We can just run `gofmt -e <filePath>`!
-        // BUT `validateSyntax` takes `code`, not `filePath`.
-        // We need `filePath` passed to `validateSyntax`.
-
-        // Refactoring `validateSyntax` signature in next step.
-        // For now, return valid to avoid breaking changes until signature update.
+        execSync('rustc --version', { stdio: 'ignore' });
+    } catch {
         return { valid: true, error: null };
-    } catch (e) {
-        return { valid: false, error: e.message };
     }
+    return validateWithCommand(code, '.rs', (f) => `rustc --parse-only "${f}"`);
 }
 
-function validateRust(code) {
+function validateJava(code) {
+    // javac is heavy, stick to Tree-sitter or basic check
     return { valid: true, error: null };
 }
 
-function validateJava(code) {
+function validatePython(code) {
+    try {
+        execSync('python3 --version', { stdio: 'ignore' });
+    } catch {
+        return { valid: true, error: null };
+    }
+    return validateWithCommand(code, '.py', (f) => `python3 -m py_compile "${f}"`);
+}
+
+function validatePHP(code) {
+    try {
+        execSync('php -v', { stdio: 'ignore' });
+    } catch {
+        return { valid: true, error: null };
+    }
+    return validateWithCommand(code, '.php', (f) => `php -l "${f}"`);
+}
+
+function validateRuby(code) {
+    try {
+        execSync('ruby -v', { stdio: 'ignore' });
+    } catch {
+        return { valid: true, error: null };
+    }
+    return validateWithCommand(code, '.rb', (f) => `ruby -c "${f}"`);
+}
+
+function validateCPP(code) {
+    try {
+        execSync('g++ --version', { stdio: 'ignore' });
+    } catch {
+        try { execSync('clang++ --version', { stdio: 'ignore' }); }
+        catch { return { valid: true, error: null }; }
+        return validateWithCommand(code, '.cpp', (f) => `clang++ -fsyntax-only "${f}"`);
+    }
+    return validateWithCommand(code, '.cpp', (f) => `g++ -fsyntax-only "${f}"`);
+}
+
+function validateCSharp(code) {
+    // dotnet build is too context heavy. Rely on Tree-sitter.
     return { valid: true, error: null };
 }

package/src/strategies/tree-sitter/index.js

@@ -9,7 +9,7 @@ import { detectLanguage } from '../syntax-validator.js'; // Reuse existing detec
  */
 export async function parse(code, filePath) {
     const language = detectLanguage(filePath);
-    if (!['go', 'rust', 'java', 'javascript', 'typescript'].includes(language)) {
+    if (!['go', 'rust', 'java', 'javascript', 'typescript', 'python', 'cpp', 'csharp', 'php', 'ruby'].includes(language)) {
         return null;
     }
 

package/src/strategies/tree-sitter/languages.js

@@ -31,6 +31,12 @@ const WASM_MAP = {
     'java': 'tree-sitter-java.wasm',
     'javascript': 'tree-sitter-javascript.wasm',
     'typescript': 'tree-sitter-javascript.wasm', // TS often uses JS or its own, using JS for now as fallback/compatible
+    'python': 'tree-sitter-python.wasm',
+    'cpp': 'tree-sitter-cpp.wasm',
+    'c': 'tree-sitter-cpp.wasm', // C typically uses C++ parser or its own. Using CPP for now as it handles C.
+    'csharp': 'tree-sitter-c-sharp.wasm',
+    'php': 'tree-sitter-php.wasm',
+    'ruby': 'tree-sitter-ruby.wasm',
 };
 
 /**

package/src/strategies/tree-sitter/queries.js

@@ -50,5 +50,76 @@ export const QUERIES = {
         organize_imports: `
             (import_statement) @import
         `
+    },
+    python: {
+        definitions: `
+            (function_definition name: (identifier) @name) @function
+            (class_definition name: (identifier) @name) @class
+        `,
+        references: `
+            (identifier) @ref
+            (attribute attribute: (identifier) @ref)
+        `,
+        organize_imports: `
+            (import_statement) @import
+            (import_from_statement) @import
+        `
+    },
+    cpp: {
+        definitions: `
+            (function_definition declarator: (function_declarator declarator: (identifier) @name)) @function
+            (class_specifier name: (type_identifier) @name) @class
+        `,
+        references: `
+            (identifier) @ref
+            (field_identifier) @ref
+            (type_identifier) @ref
+        `,
+        organize_imports: `
+            (preproc_include) @import
+        `
+    },
+    csharp: {
+        definitions: `
+            (method_declaration name: (identifier) @name) @method
+            (class_declaration name: (identifier) @name) @class
+            (interface_declaration name: (identifier) @name) @interface
+        `,
+        references: `
+            (identifier) @ref
+        `,
+        organize_imports: `
+            (using_directive) @import
+        `
+    },
+    php: {
+        definitions: `
+            (function_definition name: (name) @name) @function
+            (method_declaration name: (name) @name) @method
+            (class_declaration name: (name) @name) @class
+        `,
+        references: `
+            (name) @ref
+            (variable_name) @ref
+        `,
+        organize_imports: `
+            (namespace_use_declaration) @import
+        `
+    },
+    ruby: {
+        definitions: `
+            (method name: (identifier) @name) @method
+            (class name: (constant) @name) @class
+            (module name: (constant) @name) @module
+        `,
+        references: `
+            (identifier) @ref
+            (constant) @ref
+            (symbol) @ref
+        `,
+        organize_imports: `
+            (call method: (identifier) @method arguments: (argument_list (string) @import) (#eq? @method "require"))
+            (call method: (identifier) @method arguments: (argument_list (string) @import) (#eq? @method "require_relative"))
+        `
     }
 };

package/src/strategies/tree-sitter/refactor.js

@@ -83,6 +83,30 @@ export async function renameSymbol(code, filePath, oldName, newName) {
     return result;
 }
 
+/**
+ * Find definition of a symbol
+ */
+export async function findDefinition(code, filePath, symbolName) {
+    const language = detectLanguage(filePath);
+    if (!QUERIES[language] || !QUERIES[language].definitions) return [];
+
+    const tree = await parse(code, filePath);
+    if (!tree) return [];
+
+    const langObj = await loadLanguage(language);
+    const query = langObj.query(QUERIES[language].definitions);
+
+    const captures = query.captures(tree.rootNode);
+    return captures
+        .filter(c => c.node.text === symbolName)
+        .map(c => ({
+            line: c.node.startPosition.row + 1,
+            column: c.node.startPosition.column,
+            text: c.node.text,
+            type: c.name // 'function', 'class', etc.
+        }));
+}
+
 /**
  * Find all references of a symbol
  */
@@ -105,3 +129,154 @@ export async function findReferences(code, filePath, symbolName) {
             text: c.node.text
         }));
 }
+
+/**
+ * Organize imports (sort and remove duplicates)
+ * Currently supports simple sorting of import statements
+ */
+export async function organizeImports(code, filePath) {
+    const language = detectLanguage(filePath);
+    if (!QUERIES[language] || !QUERIES[language].organize_imports) return code;
+
+    const tree = await parse(code, filePath);
+    if (!tree) return code;
+
+    const langObj = await loadLanguage(language);
+    const query = langObj.query(QUERIES[language].organize_imports);
+
+    const captures = query.captures(tree.rootNode);
+    if (captures.length === 0) return code;
+
+    // Get unique import lines
+    const uniqueImports = new Set();
+    const range = { start: Infinity, end: -1 };
+
+    for (const c of captures) {
+        uniqueImports.add(c.node.text);
+        range.start = Math.min(range.start, c.node.startIndex);
+        range.end = Math.max(range.end, c.node.endIndex);
+    }
+
+    // Sort imports
+    const sortedImports = Array.from(uniqueImports).sort();
+
+    // Replace the entire block of imports with sorted ones
+    // Note: This assumes imports are contiguous or we are replacing the range from first to last import
+    // This handles the "block" of imports at the top
+    // A better approach would be to group them, but for "Basic" feature, contiguous block replacement is standard-ish
+    // However, if there are comments or code in between, this is risky.
+    // Safer: Replace each node? No, that doesn't sort.
+    // Safe-ish: Find the continuous block of imports at the top.
+
+    // Check if imports are contiguous (ignoring whitespace/comments)
+    // We'll just construct the new import block and replace the range from first import start to last import end
+    // But we need to keep the whitespace/newlines between them?
+    // "Organize Imports" usually means re-writing the block.
+
+    // Simplification: Join with newlines
+    const newImportBlock = sortedImports.join('\n');
+
+    // Apply replacement
+    return code.substring(0, range.start) + newImportBlock + code.substring(range.end);
+}
+
+/**
+ * Extract function helper - finds the smallest node covering the range
+ */
+export async function getExtractSelection(code, filePath, startLine, endLine) {
+    const tree = await parse(code, filePath);
+    if (!tree) return null;
+
+    const root = tree.rootNode;
+    // Find node that covers the range
+    const startNode = root.descendantForPosition({ row: startLine - 1, column: 0 });
+    const endNode = root.descendantForPosition({ row: endLine - 1, column: 1000 });
+
+    // Find common ancestor
+    let ancestor = startNode;
+    while (ancestor) {
+        if (ancestor.startIndex <= startNode.startIndex && ancestor.endIndex >= endNode.endIndex) {
+            break;
+        }
+        ancestor = ancestor.parent;
+    }
+
+    if (!ancestor) return null;
+
+    return {
+        text: ancestor.text,
+        startLine: ancestor.startPosition.row + 1,
+        endLine: ancestor.endPosition.row + 1
+    };
+}
+/**
+ * Extract code from range into a new function
+ */
+export async function extractFunction(code, filePath, startLine, endLine, functionName) {
+    const selection = await getExtractSelection(code, filePath, startLine, endLine);
+    if (!selection) throw new Error('Could not find a valid code block to extract');
+
+    const tree = await parse(code, filePath);
+    const ancestor = tree.rootNode.descendantForIndex(code.indexOf(selection.text));
+
+    // Find the body of the current function/context to insert the new function after it
+    // For simplicity, we'll append to the end of the file or insert after the current top-level parent
+    let insertionNode = ancestor;
+    while (insertionNode.parent && insertionNode.parent.type !== 'program' && insertionNode.parent.type !== 'source_file') {
+        insertionNode = insertionNode.parent;
+    }
+
+    const language = detectLanguage(filePath);
+    let newFuncTemplate = '';
+    let callTemplate = '';
+
+    if (['javascript', 'typescript'].includes(language)) {
+        newFuncTemplate = `\n\nfunction ${functionName}() {\n    ${selection.text.split('\n').join('\n    ')}\n}\n`;
+        callTemplate = `${functionName}();`;
+    } else if (language === 'python') {
+        newFuncTemplate = `\n\ndef ${functionName}():\n    ${selection.text.split('\n').join('\n    ')}\n`;
+        callTemplate = `${functionName}()`;
+    } else if (language === 'go') {
+        newFuncTemplate = `\n\nfunc ${functionName}() {\n    ${selection.text.split('\n').join('\n    ')}\n}\n`;
+        callTemplate = `${functionName}()`;
+    } else {
+        // Fallback generic
+        newFuncTemplate = `\n\nfunction ${functionName}() {\n    ${selection.text}\n}\n`;
+        callTemplate = `${functionName}();`;
+    }
+
+    // Replace original text with call
+    let result = code.substring(0, ancestor.startIndex) + callTemplate + code.substring(ancestor.endIndex);
+
+    // Insert new function after the top-level block
+    const adjustedInsertionIndex = ancestor.startIndex < insertionNode.endIndex
+        ? insertionNode.endIndex + (callTemplate.length - ancestor.text.length)
+        : insertionNode.endIndex;
+
+    result = result.substring(0, adjustedInsertionIndex) + newFuncTemplate + result.substring(adjustedInsertionIndex);
+
+    return result;
+}
+
+/**
+ * Move code from one range to another location
+ */
+export async function moveCode(code, filePath, startLine, endLine, targetLine) {
+    const selection = await getExtractSelection(code, filePath, startLine, endLine);
+    if (!selection) throw new Error('Could not find code to move');
+
+    const tree = await parse(code, filePath);
+    const ancestor = tree.rootNode.descendantForIndex(code.indexOf(selection.text));
+
+    // Remove original
+    let result = code.substring(0, ancestor.startIndex) + code.substring(ancestor.endIndex);
+
+    // Find target index
+    const lines = result.split('\n');
+    const targetIdx = targetLine > lines.length ? result.length : lines.slice(0, targetLine - 1).join('\n').length + 1;
+
+    // Insert at target
+    result = result.substring(0, targetIdx) + '\n' + selection.text + '\n' + result.substring(targetIdx);
+
+    return result;
+}