@imenam/refactoring-mcp 3.1.1 → 3.3.0

package/dist/index.js

@@ -4,7 +4,7 @@ import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"
 import { CallToolRequestSchema, ListToolsRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
 import { z } from "zod";
 import { setupLogging } from "./logger.js";
-import { executeRefactor } from "./utils/files.js";
+import { executeRefactor, insertTextAtLine } from "./utils/files.js";
 import { getFileOutline } from "./utils/outline.js";
 import { compareCodeSections } from "./utils/compare.js";
 setupLogging("MASTER");
@@ -57,6 +57,24 @@ const OutlineSchema = z.object({
         .optional()
         .describe("Optionnel : dernière ligne à analyser (1-indexé). Utile pour cibler une section du fichier. Par défaut : fin du fichier."),
 });
+const InsertTextSchema = z.object({
+    filePath: z
+        .string()
+        .describe("Chemin absolu complet du fichier cible"),
+    insertions: z
+        .array(z.object({
+        lineNumber: z
+            .number()
+            .int()
+            .positive()
+            .describe("Numéro de la ligne devant laquelle le texte sera inséré (1-indexé). Utiliser fileLength + 1 pour insérer en fin de fichier."),
+        text: z
+            .string()
+            .describe("Texte à insérer. Peut contenir plusieurs lignes (\\n)."),
+    }))
+        .min(1)
+        .describe("Liste des insertions à effectuer. Les insertions sont appliquées du bas vers le haut pour éviter les décalages d'offset. Les numéros de lignes doivent référencer le fichier dans son état ORIGINAL (avant toute insertion)."),
+});
 const CompareSchema = z.object({
     fileA: z.string().describe("Chemin absolu complet du premier fichier"),
     startLineA: z
@@ -83,6 +101,44 @@ const CompareSchema = z.object({
 });
 server.setRequestHandler(ListToolsRequestSchema, async () => ({
     tools: [
+        {
+            name: "insert_text_at_line",
+            description: "Insère du texte (potentiellement multiligne) à une ou plusieurs lignes données dans un fichier. " +
+                "Accepte un tableau d'insertions { lineNumber, text }. " +
+                "Les insertions sont appliquées du bas vers le haut pour éviter les décalages d'offset. " +
+                "Les numéros de lignes doivent référencer le fichier dans son état original (avant toute insertion). " +
+                "Retourne le nombre total de lignes insérées. " +
+                "Le chemin doit être absolu.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    filePath: {
+                        type: "string",
+                        description: "Chemin absolu complet du fichier cible",
+                    },
+                    insertions: {
+                        type: "array",
+                        description: "Liste des insertions à effectuer. Les numéros de lignes référencent le fichier dans son état original.",
+                        items: {
+                            type: "object",
+                            properties: {
+                                lineNumber: {
+                                    type: "number",
+                                    description: "Numéro de la ligne devant laquelle le texte sera inséré (1-indexé). Utiliser fileLength + 1 pour insérer en fin de fichier.",
+                                },
+                                text: {
+                                    type: "string",
+                                    description: "Texte à insérer. Peut contenir plusieurs lignes (\\n).",
+                                },
+                            },
+                            required: ["lineNumber", "text"],
+                        },
+                        minItems: 1,
+                    },
+                },
+                required: ["filePath", "insertions"],
+            },
+        },
         {
             name: "move_or_copy_code",
             description: "Copie ou déplace un bloc de lignes de code d'un fichier source vers un fichier de destination. " +
@@ -130,6 +186,7 @@ server.setRequestHandler(ListToolsRequestSchema, async () => ({
             name: "get_file_outline",
             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). " +
+                "Si un bloc de commentaire JSDoc (/** ... */) précède immédiatement un symbole, les champs commentStartLine et commentEndLine sont inclus dans la réponse. " +
                 "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.",
@@ -218,6 +275,32 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             };
         }
     }
+    if (name === "insert_text_at_line") {
+        try {
+            const validatedArgs = InsertTextSchema.parse(args);
+            const result = await insertTextAtLine(validatedArgs);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Succès : ${result.linesInserted} ligne(s) insérée(s) (${validatedArgs.insertions.length} insertion(s)).\n` +
+                            `- Fichier : ${result.fileLength} lignes après insertion`,
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Erreur : ${error.message}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    }
     if (name === "move_or_copy_code") {
         try {
             const validatedArgs = RefactorSchema.parse(args);

package/dist/utils/config.js

@@ -1,8 +1,11 @@
+// TEST INSERT A - début du fichier
 import path from "path";
 import { fileURLToPath } from "url";
 import dotenv from "dotenv";
 const rootDir = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../..");
 const envPath = path.join(rootDir, ".env");
+// TEST INSERT B - avant getConfig
+// ligne 2 du commentaire B
 export function getConfig() {
     dotenv.config({ path: envPath, override: true });
     const rawDir = process.env.REFACTORING_ALLOWED_DIR;

package/dist/utils/files.js

@@ -94,3 +94,28 @@ export async function executeRefactor(params) {
         destLength: destLines.length,
     };
 }
+export async function insertTextAtLine(params) {
+    const resolvedPath = await validateAndResolvePath(params.filePath);
+    await checkFileSize(resolvedPath);
+    const content = await fs.readFile(resolvedPath, "utf-8");
+    const fileLines = content.split(/\r?\n/);
+    const originalLength = fileLines.length;
+    for (const insertion of params.insertions) {
+        if (insertion.lineNumber < 1 || insertion.lineNumber > originalLength + 1) {
+            throw new Error(`Numéro de ligne invalide (demandé: ${insertion.lineNumber}, fichier de ${originalLength} lignes — valeurs acceptées : 1 à ${originalLength + 1})`);
+        }
+    }
+    // Tri du bas vers le haut pour éviter les décalages d'offset
+    const sorted = [...params.insertions].sort((a, b) => b.lineNumber - a.lineNumber);
+    let totalLinesInserted = 0;
+    for (const insertion of sorted) {
+        const newLines = insertion.text.split(/\r?\n/);
+        fileLines.splice(insertion.lineNumber - 1, 0, ...newLines);
+        totalLinesInserted += newLines.length;
+    }
+    await fs.writeFile(resolvedPath, fileLines.join("\n"), "utf-8");
+    return {
+        linesInserted: totalLinesInserted,
+        fileLength: fileLines.length,
+    };
+}

package/dist/utils/outline.js

@@ -33,6 +33,26 @@ const SYMBOL_PATTERNS = [
         type: "method",
     },
 ];
+function findPrecedingComment(lines, symbolLineIndex) {
+    let idx = symbolLineIndex - 1;
+    while (idx >= 0 && lines[idx].trim() === "") {
+        idx--;
+    }
+    if (idx < 0)
+        return null;
+    const trimmed = lines[idx].trim();
+    if (!trimmed.endsWith("*/"))
+        return null;
+    const commentEndLine = idx + 1;
+    while (idx >= 0) {
+        const t = lines[idx].trim();
+        if (t.startsWith("/**") || t.startsWith("/*")) {
+            return { commentStartLine: idx + 1, commentEndLine };
+        }
+        idx--;
+    }
+    return null;
+}
 function countBracesInLine(line) {
     let count = 0;
     let inSingleQuote = false;
@@ -78,7 +98,15 @@ export async function getFileOutline(filePath, options = {}) {
                     // 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 });
+                        const comment = findPrecedingComment(lines, i);
+                        symbols.push({
+                            name,
+                            type,
+                            ...(comment ?? {}),
+                            startLine: lineNum,
+                            endLine: 0,
+                            depth: braceDepth,
+                        });
                         break;
                     }
                 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@imenam/refactoring-mcp",
-  "version": "3.1.1",
+  "version": "3.3.0",
   "description": "MCP server to copy or move code blocks between files, with optional directory confinement.",
   "type": "module",
   "main": "dist/index.js",