@imenam/refactoring-mcp 2.0.0 → 3.0.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({
@@ -37,6 +39,30 @@ const OutlineSchema = z.object({
         .string()
         .describe("Chemin absolu complet du fichier à analyser"),
 });
+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: [
         {
@@ -99,6 +125,44 @@ server.setRequestHandler(ListToolsRequestSchema, async () => ({
                 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) => {
@@ -151,6 +215,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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@imenam/refactoring-mcp",
-  "version": "2.0.0",
+  "version": "3.0.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"