@imenam/refactoring-mcp 3.0.0 → 3.1.0

package/dist/index.js

@@ -38,6 +38,24 @@ 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"),
@@ -110,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",
@@ -121,6 +140,18 @@ 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"],
             },
@@ -169,8 +200,8 @@ 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) }],
             };

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": "3.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",