@imenam/refactoring-mcp 2.0.0 → 3.1.0

package/README.md

@@ -25,6 +25,21 @@ Returns the list of top-level symbols in a file (functions, classes, interfaces,
 |---|---|---|---|
 | `filePath` | `string` | ✅ | Absolute path to the file to analyse |
 
+### `compare_code_sections`
+
+Compares two code sections from two files (delimited by line numbers) and returns a unified diff in git format. Useful for verifying that a block of code was correctly copied from one file to another. Leading and trailing blank lines in each section are ignored to avoid false positives from positioning differences.
+
+| Parameter | Type | Required | Description |
+|---|---|---|---|
+| `fileA` | `string` | ✅ | Absolute path to the first file |
+| `startLineA` | `number` | ✅ | Start line of the section in file A (1-indexed) |
+| `endLineA` | `number` | ✅ | End line of the section in file A, inclusive (1-indexed) |
+| `fileB` | `string` | ✅ | Absolute path to the second file |
+| `startLineB` | `number` | ✅ | Start line of the section in file B (1-indexed) |
+| `endLineB` | `number` | ✅ | End line of the section in file B, inclusive (1-indexed) |
+
+Returns `"Les sections sont identiques."` when no differences are found, or a unified diff with real file line numbers otherwise.
+
 ## Configuration
 
 All file paths must be **absolute**. Relative paths are rejected.

package/dist/index.js

@@ -1,3 +1,4 @@
+#!/usr/bin/env node
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { CallToolRequestSchema, ListToolsRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
@@ -5,6 +6,7 @@ import { z } from "zod";
 import { setupLogging } from "./logger.js";
 import { executeRefactor } from "./utils/files.js";
 import { getFileOutline } from "./utils/outline.js";
+import { compareCodeSections } from "./utils/compare.js";
 setupLogging("MASTER");
 const server = new Server({ name: "refactoring-mcp", version: "1.0.0" }, { capabilities: { tools: {} } });
 const RefactorSchema = z.object({
@@ -36,6 +38,48 @@ const OutlineSchema = z.object({
     filePath: z
         .string()
         .describe("Chemin absolu complet du fichier à analyser"),
+    depth: z
+        .number()
+        .int()
+        .min(0)
+        .optional()
+        .describe("Optionnel : profondeur maximale des symboles à retourner. 0 = premier niveau uniquement (classes, fonctions top-level), 1 = +1 niveau imbriqué (méthodes d'une classe), etc. Par défaut : tous les niveaux."),
+    startLine: z
+        .number()
+        .int()
+        .positive()
+        .optional()
+        .describe("Optionnel : première ligne à analyser (1-indexé). Utile pour cibler une section du fichier. Par défaut : début du fichier."),
+    endLine: z
+        .number()
+        .int()
+        .positive()
+        .optional()
+        .describe("Optionnel : dernière ligne à analyser (1-indexé). Utile pour cibler une section du fichier. Par défaut : fin du fichier."),
+});
+const CompareSchema = z.object({
+    fileA: z.string().describe("Chemin absolu complet du premier fichier"),
+    startLineA: z
+        .number()
+        .int()
+        .positive()
+        .describe("Ligne de début de la section dans le fichier A (1-indexé)"),
+    endLineA: z
+        .number()
+        .int()
+        .positive()
+        .describe("Ligne de fin de la section dans le fichier A (1-indexé, incluse)"),
+    fileB: z.string().describe("Chemin absolu complet du second fichier"),
+    startLineB: z
+        .number()
+        .int()
+        .positive()
+        .describe("Ligne de début de la section dans le fichier B (1-indexé)"),
+    endLineB: z
+        .number()
+        .int()
+        .positive()
+        .describe("Ligne de fin de la section dans le fichier B (1-indexé, incluse)"),
 });
 server.setRequestHandler(ListToolsRequestSchema, async () => ({
     tools: [
@@ -84,9 +128,10 @@ server.setRequestHandler(ListToolsRequestSchema, async () => ({
         },
         {
             name: "get_file_outline",
-            description: "Retourne la liste des symboles de premier niveau d'un fichier " +
-                "(fonctions, classes, interfaces, types, constantes, méthodes) avec leurs numéros de lignes de début et de fin. " +
-                "Utile pour identifier les coordonnées précises d'un bloc de code avant de le déplacer. " +
+            description: "Retourne la liste des symboles d'un fichier (fonctions, classes, interfaces, types, constantes, méthodes) " +
+                "avec leurs numéros de lignes de début et de fin, et leur profondeur d'imbrication (depth). " +
+                "Supporte tous les langages à accolades (TypeScript, JavaScript, PHP, Java, C#…). " +
+                "Paramètres optionnels : depth pour filtrer par niveau d'imbrication, startLine/endLine pour cibler une section. " +
                 "Le chemin doit être absolu.",
             inputSchema: {
                 type: "object",
@@ -95,18 +140,68 @@ server.setRequestHandler(ListToolsRequestSchema, async () => ({
                         type: "string",
                         description: "Chemin absolu complet du fichier à analyser",
                     },
+                    depth: {
+                        type: "number",
+                        description: "Optionnel : profondeur maximale à retourner. 0 = premier niveau uniquement (classes, fonctions top-level), 1 = +1 niveau (méthodes d'une classe), etc. Par défaut : tous les niveaux.",
+                    },
+                    startLine: {
+                        type: "number",
+                        description: "Optionnel : première ligne à analyser (1-indexé). Par défaut : début du fichier.",
+                    },
+                    endLine: {
+                        type: "number",
+                        description: "Optionnel : dernière ligne à analyser (1-indexé). Par défaut : fin du fichier.",
+                    },
                 },
                 required: ["filePath"],
             },
         },
+        {
+            name: "compare_code_sections",
+            description: "Compare deux sections de code (délimitées par des numéros de lignes) issues de deux fichiers. " +
+                "Retourne un diff au format unifié (style git) avec les numéros de lignes réels dans les fichiers. " +
+                "Utile pour vérifier qu'un bloc de code a été correctement recopié d'un fichier à l'autre. " +
+                "Les lignes vides en début et en fin de chaque section sont ignorées pour éviter les faux positifs. " +
+                "Tous les chemins doivent être absolus.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    fileA: {
+                        type: "string",
+                        description: "Chemin absolu complet du premier fichier",
+                    },
+                    startLineA: {
+                        type: "number",
+                        description: "Ligne de début de la section dans le fichier A (1-indexé)",
+                    },
+                    endLineA: {
+                        type: "number",
+                        description: "Ligne de fin de la section dans le fichier A (1-indexé, incluse)",
+                    },
+                    fileB: {
+                        type: "string",
+                        description: "Chemin absolu complet du second fichier",
+                    },
+                    startLineB: {
+                        type: "number",
+                        description: "Ligne de début de la section dans le fichier B (1-indexé)",
+                    },
+                    endLineB: {
+                        type: "number",
+                        description: "Ligne de fin de la section dans le fichier B (1-indexé, incluse)",
+                    },
+                },
+                required: ["fileA", "startLineA", "endLineA", "fileB", "startLineB", "endLineB"],
+            },
+        },
     ],
 }));
 server.setRequestHandler(CallToolRequestSchema, async (request) => {
     const { name, arguments: args } = request.params;
     if (name === "get_file_outline") {
         try {
-            const { filePath } = OutlineSchema.parse(args);
-            const symbols = await getFileOutline(filePath);
+            const { filePath, depth, startLine, endLine } = OutlineSchema.parse(args);
+            const symbols = await getFileOutline(filePath, { depth, startLine, endLine });
             return {
                 content: [{ type: "text", text: JSON.stringify(symbols, null, 2) }],
             };
@@ -151,6 +246,26 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             };
         }
     }
+    if (name === "compare_code_sections") {
+        try {
+            const validatedArgs = CompareSchema.parse(args);
+            const result = await compareCodeSections(validatedArgs);
+            return {
+                content: [{ type: "text", text: result }],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Erreur : ${error.message}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    }
     return {
         content: [{ type: "text", text: `Outil inconnu : ${name}` }],
         isError: true,

package/dist/utils/compare.js

@@ -0,0 +1,48 @@
+import fs from "fs/promises";
+import { createTwoFilesPatch } from "diff";
+import { validateAndResolvePath, checkFileSize } from "./files.js";
+function trimBlankLines(lines) {
+    let start = 0;
+    while (start < lines.length && lines[start].trim() === "")
+        start++;
+    let end = lines.length - 1;
+    while (end > start && lines[end].trim() === "")
+        end--;
+    return lines.slice(start, end + 1);
+}
+function adjustDiffLineNumbers(patch, offsetA, offsetB) {
+    return patch.replace(/@@ -(\d+),(\d+) \+(\d+),(\d+) @@/g, (_, a1, a2, b1, b2) => `@@ -${parseInt(a1) + offsetA},${a2} +${parseInt(b1) + offsetB},${b2} @@`);
+}
+export async function compareCodeSections(params) {
+    const pathA = await validateAndResolvePath(params.fileA);
+    const pathB = await validateAndResolvePath(params.fileB);
+    await checkFileSize(pathA);
+    await checkFileSize(pathB);
+    const contentA = await fs.readFile(pathA, "utf-8");
+    const contentB = await fs.readFile(pathB, "utf-8");
+    const linesA = contentA.split(/\r?\n/);
+    const linesB = contentB.split(/\r?\n/);
+    const { startLineA, endLineA, startLineB, endLineB } = params;
+    if (startLineA < 1 || endLineA > linesA.length || startLineA > endLineA) {
+        throw new Error(`Lignes invalides pour le fichier A (demandées: ${startLineA}-${endLineA}, fichier de ${linesA.length} lignes)`);
+    }
+    if (startLineB < 1 || endLineB > linesB.length || startLineB > endLineB) {
+        throw new Error(`Lignes invalides pour le fichier B (demandées: ${startLineB}-${endLineB}, fichier de ${linesB.length} lignes)`);
+    }
+    const rawSectionA = linesA.slice(startLineA - 1, endLineA);
+    const rawSectionB = linesB.slice(startLineB - 1, endLineB);
+    const sectionA = trimBlankLines(rawSectionA);
+    const sectionB = trimBlankLines(rawSectionB);
+    // Offset = number of blank lines trimmed from the start of each section
+    const trimOffsetA = rawSectionA.indexOf(sectionA[0] ?? "");
+    const trimOffsetB = rawSectionB.indexOf(sectionB[0] ?? "");
+    const textA = sectionA.join("\n") + "\n";
+    const textB = sectionB.join("\n") + "\n";
+    if (textA === textB) {
+        return "Les sections sont identiques.";
+    }
+    const rawPatch = createTwoFilesPatch(`${params.fileA} (lignes ${startLineA}-${endLineA})`, `${params.fileB} (lignes ${startLineB}-${endLineB})`, textA, textB);
+    const absoluteOffsetA = startLineA - 1 + trimOffsetA;
+    const absoluteOffsetB = startLineB - 1 + trimOffsetB;
+    return adjustDiffLineNumbers(rawPatch, absoluteOffsetA, absoluteOffsetB);
+}

package/dist/utils/outline.js

@@ -21,35 +21,81 @@ const SYMBOL_PATTERNS = [
         regex: /^(?:export\s+)?(?:const|let|var)\s+(\w+)\s*[=:]/,
         type: "const",
     },
-    // Méthodes dans une classe (indentées d'au moins 2 espaces/tab)
-    // On exclut les mots-clés JS/TS pour éviter les faux positifs (if, for, while, switch, catch, return...)
+    // Méthodes PHP et autres langages : mot-clé `function` indenté
+    {
+        regex: /^[ \t]+(?:(?:public|private|protected|static|abstract|final|async|override)\s+)*function\s+(\w+)/,
+        type: "method",
+    },
+    // Méthodes TypeScript/JS indentées sans mot-clé `function`
+    // On exclut les mots-clés pour éviter les faux positifs
     {
         regex: /^[ \t]{2,}(?:(?:public|private|protected|static|async|override)\s+)*(?!(if|for|while|switch|catch|return|throw|new|typeof|instanceof|await|yield|delete|void|case|else|do)\b)(\w+)\s*[(<]/,
         type: "method",
     },
 ];
-export async function getFileOutline(filePath) {
+function countBracesInLine(line) {
+    let count = 0;
+    let inSingleQuote = false;
+    let inDoubleQuote = false;
+    for (let i = 0; i < line.length; i++) {
+        const ch = line[i];
+        if (ch === "'" && !inDoubleQuote)
+            inSingleQuote = !inSingleQuote;
+        else if (ch === '"' && !inSingleQuote)
+            inDoubleQuote = !inDoubleQuote;
+        else if (!inSingleQuote && !inDoubleQuote) {
+            if (ch === "{")
+                count++;
+            else if (ch === "}")
+                count--;
+        }
+    }
+    return count;
+}
+export async function getFileOutline(filePath, options = {}) {
     const resolved = await validateAndResolvePath(filePath);
     await checkFileSize(resolved);
     const content = await fs.readFile(resolved, "utf-8");
     const lines = content.split(/\r?\n/);
+    const rangeStart = options.startLine ?? 1;
+    const rangeEnd = options.endLine ?? lines.length;
     const symbols = [];
+    let braceDepth = 0;
     for (let i = 0; i < lines.length; i++) {
+        const lineNum = i + 1;
         const line = lines[i];
-        for (const { regex, type } of SYMBOL_PATTERNS) {
-            const match = line.match(regex);
-            if (match && match[1]) {
-                // Pour le pattern "method", le groupe capturant est match[2] car match[1] est le lookahead
-                const name = match[2] ?? match[1];
-                symbols.push({ name, type, startLine: i + 1, endLine: 0 });
-                break;
+        if (lineNum >= rangeStart && lineNum <= rangeEnd) {
+            for (const { regex, type } of SYMBOL_PATTERNS) {
+                const match = line.match(regex);
+                if (match) {
+                    // Pour le pattern TS method, le groupe capturant est match[2] (match[1] = lookahead interne)
+                    const name = match[2] ?? match[1];
+                    if (name) {
+                        symbols.push({ name, type, startLine: lineNum, endLine: 0, depth: braceDepth });
+                        break;
+                    }
+                }
             }
         }
+        braceDepth += countBracesInLine(line);
+        if (braceDepth < 0)
+            braceDepth = 0;
     }
-    // Calculer les lignes de fin : fin du symbole = début du suivant - 1 (ou fin du fichier)
+    // Calculer endLine en tenant compte de la profondeur :
+    // un symbole se termine juste avant le prochain symbole de même niveau ou supérieur
     for (let i = 0; i < symbols.length; i++) {
-        symbols[i].endLine =
-            i + 1 < symbols.length ? symbols[i + 1].startLine - 1 : lines.length;
+        const currentDepth = symbols[i].depth;
+        let nextBoundaryLine = rangeEnd + 1;
+        for (let j = i + 1; j < symbols.length; j++) {
+            if (symbols[j].depth <= currentDepth) {
+                nextBoundaryLine = symbols[j].startLine;
+                break;
+            }
+        }
+        symbols[i].endLine = Math.min(nextBoundaryLine - 1, rangeEnd);
+    }
+    if (options.depth !== undefined) {
+        return symbols.filter((s) => s.depth <= options.depth);
     }
     return symbols;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@imenam/refactoring-mcp",
-  "version": "2.0.0",
+  "version": "3.1.0",
   "description": "MCP server to copy or move code blocks between files, with optional directory confinement.",
   "type": "module",
   "main": "dist/index.js",
@@ -15,9 +15,9 @@
     "start": "node dist/index.js",
     "dev": "tsx src/index.ts",
     "prepublishOnly": "npm run build",
-    "release:patch": "npm version patch && npm publish --access public && git push origin main --follow-tags",
-    "release:minor": "npm version minor && npm publish --access public && git push origin main --follow-tags",
-    "release:major": "npm version major && npm publish --access public && git push origin main --follow-tags"
+    "release:patch": "npm version patch && npm publish --access public && git push origin master --follow-tags",
+    "release:minor": "npm version minor && npm publish --access public && git push origin master --follow-tags",
+    "release:major": "npm version major && npm publish --access public && git push origin master --follow-tags"
   },
   "keywords": [
     "mcp",
@@ -38,10 +38,12 @@
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.29.0",
+    "diff": "^9.0.0",
     "dotenv": "^17.4.2",
     "zod": "^4.4.3"
   },
   "devDependencies": {
+    "@types/diff": "^7.0.2",
     "@types/node": "^25.9.1",
     "tsx": "^4.22.3",
     "typescript": "^6.0.3"