@azerate/claudette-mcp 1.0.0 → 1.2.0

package/dist/index.js

@@ -2,444 +2,27 @@
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { CallToolRequestSchema, ListToolsRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
-import { execSync } from "child_process";
-import { existsSync, readFileSync, writeFileSync, mkdirSync, unlinkSync } from "fs";
-import { join } from "path";
-import { homedir } from "os";
+// Import from extracted modules
+import { getScripts, getScriptOutput, startScript, stopScript } from './scripts.js';
+import { getWorkspaceConfig, saveWorkspaceConfig, clearMemory, deleteMemoryNotes, replaceMemory } from './workspace.js';
+import { getCheckpoints, createCheckpoint, restoreCheckpoint, deleteCheckpoint } from './checkpoints.js';
+import { getGitChanges } from './git.js';
+import { getTypeScriptErrors } from './errors.js';
+import { getPendingAction } from './actions.js';
 // Claudette server API base URL
 const CLAUDETTE_API = "http://localhost:52001";
-// Claudette data directory
-const DATA_DIR = join(homedir(), ".claudette");
-const WORKSPACE_CONFIGS_DIR = join(DATA_DIR, "workspace-configs");
-// Strip ANSI escape codes
-function stripAnsi(str) {
-    return str
-        .replace(/\x1b\[[0-9;]*[a-zA-Z]/g, '')
-        .replace(/\x1b\][^\x07]*\x07/g, '')
-        .replace(/\x1b[()][AB012]/g, '')
-        .replace(/\x1b[>=]/g, '')
-        .replace(/\x07/g, '')
-        .replace(/\r/g, '')
-        .replace(/\x1b\[\?[0-9;]*[a-zA-Z]/g, '');
-}
-// Get list of scripts from workspace
-async function getScripts(workspacePath) {
-    try {
-        const response = await fetch(`${CLAUDETTE_API}/api/scripts?path=${encodeURIComponent(workspacePath)}`);
-        if (!response.ok)
-            return { scripts: [], hasPackageJson: false };
-        return await response.json();
-    }
-    catch {
-        return { scripts: [], hasPackageJson: false };
-    }
-}
-// Get script output
-async function getScriptOutput(workspacePath, scriptName) {
-    try {
-        const response = await fetch(`${CLAUDETTE_API}/api/scripts/status?path=${encodeURIComponent(workspacePath)}&scriptName=${encodeURIComponent(scriptName)}`);
-        if (!response.ok)
-            return null;
-        const data = await response.json();
-        if (!data.found || !data.script)
-            return null;
-        // Join output lines and strip ANSI codes
-        const output = data.script.output.join('');
-        return stripAnsi(output);
-    }
-    catch {
-        return null;
-    }
-}
-// Start a script
-async function startScript(workspacePath, scriptName) {
-    try {
-        const response = await fetch(`${CLAUDETTE_API}/api/scripts/run`, {
-            method: 'POST',
-            headers: { 'Content-Type': 'application/json' },
-            body: JSON.stringify({ path: workspacePath, scriptName, autoLaunchBrowser: true }),
-        });
-        return await response.json();
-    }
-    catch (err) {
-        return { success: false, error: err.message };
-    }
-}
-// Stop a script
-async function stopScript(workspacePath, scriptName) {
-    try {
-        const response = await fetch(`${CLAUDETTE_API}/api/scripts/stop`, {
-            method: 'POST',
-            headers: { 'Content-Type': 'application/json' },
-            body: JSON.stringify({ path: workspacePath, scriptName }),
-        });
-        return await response.json();
-    }
-    catch (err) {
-        return { success: false, error: err.message };
-    }
-}
-// Read pending action from file (file-based approach for reliability)
-function getPendingAction(workspacePath) {
-    const filePath = join(workspacePath, '.claudette', 'pending-action.json');
-    if (!existsSync(filePath)) {
-        return null;
-    }
-    try {
-        const content = readFileSync(filePath, 'utf-8');
-        const action = JSON.parse(content);
-        // Check if action is too old (5 minutes)
-        if (Date.now() - action.timestamp > 5 * 60 * 1000) {
-            unlinkSync(filePath);
-            return null;
-        }
-        // Delete the file after reading (consume it)
-        unlinkSync(filePath);
-        return action;
-    }
-    catch {
-        // Try to clean up corrupted file
-        try {
-            unlinkSync(filePath);
-        }
-        catch { }
-        return null;
-    }
-}
-// Get workspace config path
-function getWorkspaceConfigPath(workspacePath) {
-    const safeName = workspacePath.replace(/[\\/:*?"<>|]/g, "-").replace(/--+/g, "-");
-    return join(WORKSPACE_CONFIGS_DIR, `${safeName}.json`);
-}
-// Read workspace config
-function getWorkspaceConfig(workspacePath) {
-    const configPath = getWorkspaceConfigPath(workspacePath);
-    if (!existsSync(configPath))
-        return null;
-    try {
-        return JSON.parse(readFileSync(configPath, "utf-8"));
-    }
-    catch {
-        return null;
-    }
-}
-// Save workspace config
-function saveWorkspaceConfig(config) {
-    if (!existsSync(WORKSPACE_CONFIGS_DIR)) {
-        mkdirSync(WORKSPACE_CONFIGS_DIR, { recursive: true });
-    }
-    const configPath = getWorkspaceConfigPath(config.path);
-    writeFileSync(configPath, JSON.stringify(config, null, 2));
-}
-// Check TypeScript errors
-function getTypeScriptErrors(workspacePath) {
-    const errors = [];
-    try {
-        // Check if tsconfig exists
-        if (!existsSync(join(workspacePath, "tsconfig.json"))) {
-            return [];
-        }
-        // Run TypeScript compiler
-        execSync("npx tsc --noEmit 2>&1", {
-            cwd: workspacePath,
-            encoding: "utf-8",
-            maxBuffer: 10 * 1024 * 1024,
-        });
-    }
-    catch (err) {
-        const output = err.stdout || err.message || "";
-        // Parse TypeScript errors: src/file.ts(10,5): error TS2322: ...
-        const errorRegex = /^(.+?)\((\d+),(\d+)\):\s*(error|warning)\s*(TS\d+):\s*(.+)$/gm;
-        let match;
-        while ((match = errorRegex.exec(output)) !== null) {
-            errors.push({
-                file: match[1],
-                line: parseInt(match[2], 10),
-                column: parseInt(match[3], 10),
-                severity: match[4],
-                code: match[5],
-                message: match[6],
-            });
-        }
-    }
-    return errors;
-}
-// Get checkpoints (git stashes)
-function getCheckpoints(workspacePath) {
-    const checkpoints = [];
-    try {
-        const output = execSync("git stash list", {
-            cwd: workspacePath,
-            encoding: "utf-8",
-        });
-        if (!output.trim())
-            return [];
-        const lines = output.trim().split("\n");
-        for (const line of lines) {
-            const match = line.match(/^(stash@\{(\d+)\}):\s*(?:On\s+\w+:\s*)?(?:WIP on \w+:\s*\w+\s*)?(.+)$/);
-            if (match) {
-                const id = match[1];
-                let message = match[3].trim().replace(/^[a-f0-9]+\s+/, "");
-                try {
-                    const dateOutput = execSync(`git log -1 --format="%ci" ${id}`, {
-                        cwd: workspacePath,
-                        encoding: "utf-8",
-                    }).trim();
-                    let filesChanged = 0;
-                    try {
-                        const diffOutput = execSync(`git stash show ${id} --stat`, {
-                            cwd: workspacePath,
-                            encoding: "utf-8",
-                        });
-                        const filesMatch = diffOutput.match(/(\d+)\s+files?\s+changed/);
-                        if (filesMatch)
-                            filesChanged = parseInt(filesMatch[1]);
-                    }
-                    catch { }
-                    checkpoints.push({ id, message, timestamp: dateOutput, filesChanged });
-                }
-                catch { }
-            }
-        }
-    }
-    catch { }
-    return checkpoints;
-}
-// Create a checkpoint
-function createCheckpoint(workspacePath, message) {
-    try {
-        const status = execSync("git status --porcelain", {
-            cwd: workspacePath,
-            encoding: "utf-8",
-        }).trim();
-        if (!status) {
-            return { success: false, error: "No changes to checkpoint" };
-        }
-        // Stage tracked files
-        try {
-            execSync("git add -u", { cwd: workspacePath, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] });
-        }
-        catch { }
-        // Create stash without removing changes
-        const stashHash = execSync("git stash create", {
-            cwd: workspacePath,
-            encoding: "utf-8",
-            stdio: ["pipe", "pipe", "pipe"],
-        }).trim();
-        if (!stashHash) {
-            return { success: false, error: "Failed to create checkpoint" };
-        }
-        // Generate name from changes if not provided
-        const stashMessage = message || generateCheckpointName(status);
-        execSync(`git stash store -m "${stashMessage.replace(/"/g, '\\"')}" ${stashHash}`, {
-            cwd: workspacePath,
-            encoding: "utf-8",
-        });
-        return { success: true };
-    }
-    catch (err) {
-        return { success: false, error: err.message };
-    }
-}
-// Generate checkpoint name from git status
-function generateCheckpointName(status) {
-    const lines = status.trim().split("\n").filter(Boolean);
-    const changes = {
-        modified: [], added: [], deleted: [],
-    };
-    for (const line of lines) {
-        const code = line.substring(0, 2);
-        const file = line.substring(3).split("/").pop() || line.substring(3);
-        if (code.includes("M"))
-            changes.modified.push(file);
-        else if (code.includes("A") || code.includes("?"))
-            changes.added.push(file);
-        else if (code.includes("D"))
-            changes.deleted.push(file);
-    }
-    const parts = [];
-    if (changes.modified.length > 0) {
-        parts.push(changes.modified.length <= 2 ? `Edit ${changes.modified.join(", ")}` : `Edit ${changes.modified.length} files`);
-    }
-    if (changes.added.length > 0) {
-        parts.push(changes.added.length <= 2 ? `Add ${changes.added.join(", ")}` : `Add ${changes.added.length} files`);
-    }
-    if (changes.deleted.length > 0) {
-        parts.push(changes.deleted.length <= 2 ? `Delete ${changes.deleted.join(", ")}` : `Delete ${changes.deleted.length} files`);
-    }
-    if (parts.length === 0)
-        return `Checkpoint ${new Date().toLocaleTimeString()}`;
-    let result = parts.join(", ");
-    return result.length > 60 ? result.substring(0, 57) + "..." : result;
-}
-// Restore a checkpoint
-function restoreCheckpoint(workspacePath, id) {
-    try {
-        // Parse original stash index to calculate new index after auto-save
-        const stashMatch = id.match(/stash@\{(\d+)\}/);
-        if (!stashMatch) {
-            return { success: false, error: "Invalid checkpoint ID" };
-        }
-        let stashIndex = parseInt(stashMatch[1], 10);
-        let autoSaveCreated = false;
-        // Auto-save current changes first
-        const status = execSync("git status --porcelain", {
-            cwd: workspacePath,
-            encoding: "utf-8",
-        }).trim();
-        if (status) {
-            try {
-                execSync("git add -u", { cwd: workspacePath, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] });
-            }
-            catch { }
-            const stashHash = execSync("git stash create", {
-                cwd: workspacePath,
-                encoding: "utf-8",
-                stdio: ["pipe", "pipe", "pipe"],
-            }).trim();
-            if (stashHash) {
-                execSync(`git stash store -m "Auto-save before restore" ${stashHash}`, {
-                    cwd: workspacePath,
-                    encoding: "utf-8",
-                });
-                // Stash indices shifted up by 1
-                stashIndex += 1;
-                autoSaveCreated = true;
-            }
-        }
-        // Reset working directory completely
-        execSync("git reset --hard HEAD", {
-            cwd: workspacePath,
-            encoding: "utf-8",
-            stdio: ["pipe", "pipe", "pipe"],
-        });
-        // Clean untracked files to prevent conflicts
-        execSync("git clean -fd", {
-            cwd: workspacePath,
-            encoding: "utf-8",
-            stdio: ["pipe", "pipe", "pipe"],
-        });
-        // Apply the checkpoint with adjusted index
-        try {
-            execSync(`git stash apply stash@{${stashIndex}}`, {
-                cwd: workspacePath,
-                encoding: "utf-8",
-                stdio: ["pipe", "pipe", "pipe"],
-            });
-        }
-        catch (applyErr) {
-            // Check if there are conflict markers in the working directory
-            try {
-                const conflictCheck = execSync("git diff --check", {
-                    cwd: workspacePath,
-                    encoding: "utf-8",
-                    stdio: ["pipe", "pipe", "pipe"],
-                });
-            }
-            catch (diffErr) {
-                const diffOutput = diffErr.stdout || diffErr.message || "";
-                if (diffOutput.includes("conflict") || diffOutput.includes("leftover")) {
-                    // Conflicts detected - abort and reset to clean state
-                    execSync("git reset --hard HEAD", {
-                        cwd: workspacePath,
-                        encoding: "utf-8",
-                        stdio: ["pipe", "pipe", "pipe"],
-                    });
-                    execSync("git clean -fd", {
-                        cwd: workspacePath,
-                        encoding: "utf-8",
-                        stdio: ["pipe", "pipe", "pipe"],
-                    });
-                    return {
-                        success: false,
-                        error: "Checkpoint restore failed due to conflicts. Working directory reset to clean state." +
-                            (autoSaveCreated ? " Your changes were saved as stash@{0}." : "")
-                    };
-                }
-            }
-            // Also check for conflict markers in files directly
-            try {
-                const grepConflict = execSync("git grep -l \"^<<<<<<<\" || true", {
-                    cwd: workspacePath,
-                    encoding: "utf-8",
-                    stdio: ["pipe", "pipe", "pipe"],
-                }).trim();
-                if (grepConflict) {
-                    // Conflict markers found - abort
-                    execSync("git reset --hard HEAD", {
-                        cwd: workspacePath,
-                        encoding: "utf-8",
-                        stdio: ["pipe", "pipe", "pipe"],
-                    });
-                    execSync("git clean -fd", {
-                        cwd: workspacePath,
-                        encoding: "utf-8",
-                        stdio: ["pipe", "pipe", "pipe"],
-                    });
-                    return {
-                        success: false,
-                        error: "Checkpoint restore created merge conflicts. Aborted and reset to clean state." +
-                            (autoSaveCreated ? " Your changes were saved as stash@{0}." : "")
-                    };
-                }
-            }
-            catch { }
-            // If we got here, the apply error wasn't about conflicts - re-throw
-            throw applyErr;
-        }
-        return {
-            success: true,
-            autoSaveId: autoSaveCreated ? "stash@{0}" : undefined
-        };
-    }
-    catch (err) {
-        return { success: false, error: err.message };
-    }
-}
-// Delete a checkpoint
-function deleteCheckpoint(workspacePath, id) {
+// Helper to log refactor activity
+async function logRefactorActivity(workspacePath, type, action, message, details) {
     try {
-        execSync(`git stash drop ${id}`, {
-            cwd: workspacePath,
-            encoding: "utf-8",
+        await fetch(`${CLAUDETTE_API}/api/refactor/activity`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ path: workspacePath, type, action, message, details }),
         });
-        return { success: true };
-    }
-    catch (err) {
-        return { success: false, error: err.message };
-    }
-}
-// Get git changes
-function getGitChanges(workspacePath) {
-    const changes = [];
-    try {
-        const output = execSync("git status --porcelain", {
-            cwd: workspacePath,
-            encoding: "utf-8",
-        });
-        const lines = output.trim().split("\n").filter(Boolean);
-        for (const line of lines) {
-            const staged = line[0] !== " " && line[0] !== "?";
-            const statusCode = line.substring(0, 2).trim();
-            const file = line.substring(3);
-            let status = "unknown";
-            if (statusCode.includes("M"))
-                status = "modified";
-            else if (statusCode.includes("A"))
-                status = "added";
-            else if (statusCode.includes("D"))
-                status = "deleted";
-            else if (statusCode.includes("R"))
-                status = "renamed";
-            else if (statusCode.includes("?"))
-                status = "untracked";
-            changes.push({ file, status, staged });
-        }
     }
     catch {
-        // Not a git repo or git not available
+        // Ignore logging errors - don't break the main flow
     }
-    return changes;
 }
 // Create the MCP server
 const server = new Server({
@@ -514,6 +97,58 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
                     required: ["workspace_path", "note"],
                 },
             },
+            {
+                name: "clear_memory",
+                description: "Clear all project memory notes. Use this before writing a fresh summary.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        workspace_path: {
+                            type: "string",
+                            description: "Path to the workspace directory",
+                        },
+                    },
+                    required: ["workspace_path"],
+                },
+            },
+            {
+                name: "delete_memory",
+                description: "Delete specific memory notes by their index (0-based). Use get_memory first to see indices.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        workspace_path: {
+                            type: "string",
+                            description: "Path to the workspace directory",
+                        },
+                        indices: {
+                            type: "array",
+                            items: { type: "number" },
+                            description: "Array of note indices to delete (0-based)",
+                        },
+                    },
+                    required: ["workspace_path", "indices"],
+                },
+            },
+            {
+                name: "replace_memory",
+                description: "Replace all memory with new notes. Use for summarizing/consolidating existing notes into fewer, more concise notes.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        workspace_path: {
+                            type: "string",
+                            description: "Path to the workspace directory",
+                        },
+                        notes: {
+                            type: "array",
+                            items: { type: "string" },
+                            description: "Array of new notes to replace all existing memory",
+                        },
+                    },
+                    required: ["workspace_path", "notes"],
+                },
+            },
             {
                 name: "get_checkpoints",
                 description: "Get all saved checkpoints (snapshots) for the workspace. Checkpoints allow reverting to previous states.",
@@ -664,6 +299,126 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
                     required: ["workspace_path"],
                 },
             },
+            {
+                name: "create_refactor_plan",
+                description: "Analyze workspace for files needing refactoring and create a verified plan. Automatically detects test framework (Jest, Vitest, pytest, Go, etc.), runs tests to capture baseline, and generates step-by-step refactoring instructions with test verification checkpoints. IMPORTANT: Always use verify_refactor after each extraction to ensure no regressions.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        workspace_path: {
+                            type: "string",
+                            description: "Path to the workspace directory",
+                        },
+                    },
+                    required: ["workspace_path"],
+                },
+            },
+            {
+                name: "get_refactor_plan",
+                description: "Get the current refactor plan for the workspace. Returns the full plan with file analysis and suggestions. Use this to read the plan before performing refactoring.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        workspace_path: {
+                            type: "string",
+                            description: "Path to the workspace directory",
+                        },
+                    },
+                    required: ["workspace_path"],
+                },
+            },
+            {
+                name: "complete_refactor",
+                description: "Mark the refactoring as complete and delete the refactor plan file. Call this after you have finished all refactoring tasks.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        workspace_path: {
+                            type: "string",
+                            description: "Path to the workspace directory",
+                        },
+                    },
+                    required: ["workspace_path"],
+                },
+            },
+            {
+                name: "verify_refactor",
+                description: "Run tests and compare against baseline to verify refactoring didn't break anything. Use this AFTER each extract_module step. Returns success if tests pass and match baseline, or detailed failure info if regression detected.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        workspace_path: {
+                            type: "string",
+                            description: "Path to the workspace directory",
+                        },
+                    },
+                    required: ["workspace_path"],
+                },
+            },
+            {
+                name: "complete_refactor_step",
+                description: "Mark a refactoring step as completed. Call this after successfully completing each step in the refactor plan.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        workspace_path: {
+                            type: "string",
+                            description: "Path to the workspace directory",
+                        },
+                        step_id: {
+                            type: "number",
+                            description: "The step ID to mark as completed",
+                        },
+                    },
+                    required: ["workspace_path", "step_id"],
+                },
+            },
+            {
+                name: "get_next_refactor_step",
+                description: "Get the next uncompleted step in the refactor plan. Returns the step details or null if all steps are complete.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        workspace_path: {
+                            type: "string",
+                            description: "Path to the workspace directory",
+                        },
+                    },
+                    required: ["workspace_path"],
+                },
+            },
+            {
+                name: "run_tests",
+                description: "Run Jest tests for the workspace. Returns test results including passed/failed counts and failure messages.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        workspace_path: {
+                            type: "string",
+                            description: "Path to the workspace directory",
+                        },
+                        test_file: {
+                            type: "string",
+                            description: "Optional specific test file to run",
+                        },
+                    },
+                    required: ["workspace_path"],
+                },
+            },
+            {
+                name: "get_test_results",
+                description: "Get the latest Jest test results for the workspace. Use this after running tests to see detailed results.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        workspace_path: {
+                            type: "string",
+                            description: "Path to the workspace directory",
+                        },
+                    },
+                    required: ["workspace_path"],
+                },
+            },
         ],
     };
 });
@@ -739,6 +494,42 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             saveWorkspaceConfig(config);
             return { content: [{ type: "text", text: `Added to project memory: "${note}"` }] };
         }
+        case "clear_memory": {
+            const workspacePath = args?.workspace_path;
+            if (!workspacePath) {
+                return { content: [{ type: "text", text: "Error: workspace_path is required" }] };
+            }
+            const success = clearMemory(workspacePath);
+            if (success) {
+                return { content: [{ type: "text", text: "Project memory cleared." }] };
+            }
+            else {
+                return { content: [{ type: "text", text: "No memory to clear or workspace not found." }] };
+            }
+        }
+        case "delete_memory": {
+            const workspacePath = args?.workspace_path;
+            const indices = args?.indices;
+            if (!workspacePath || !indices || !Array.isArray(indices)) {
+                return { content: [{ type: "text", text: "Error: workspace_path and indices array are required" }] };
+            }
+            const deleted = deleteMemoryNotes(workspacePath, indices);
+            return { content: [{ type: "text", text: `Deleted ${deleted} note(s) from project memory.` }] };
+        }
+        case "replace_memory": {
+            const workspacePath = args?.workspace_path;
+            const notes = args?.notes;
+            if (!workspacePath || !notes || !Array.isArray(notes)) {
+                return { content: [{ type: "text", text: "Error: workspace_path and notes array are required" }] };
+            }
+            const success = replaceMemory(workspacePath, notes);
+            if (success) {
+                return { content: [{ type: "text", text: `Replaced memory with ${notes.length} new note(s).` }] };
+            }
+            else {
+                return { content: [{ type: "text", text: "Failed to replace memory." }] };
+            }
+        }
         case "get_checkpoints": {
             const workspacePath = args?.workspace_path;
             if (!workspacePath) {
@@ -877,6 +668,341 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                 return { content: [{ type: "text", text: "No pending quick actions from Claudette IDE." }] };
             }
         }
+        case "create_refactor_plan": {
+            const workspacePath = args?.workspace_path;
+            if (!workspacePath) {
+                return { content: [{ type: "text", text: "Error: workspace_path is required" }] };
+            }
+            try {
+                const response = await fetch(`${CLAUDETTE_API}/api/refactor/analyze`, {
+                    method: "POST",
+                    headers: { "Content-Type": "application/json" },
+                    body: JSON.stringify({ path: workspacePath }),
+                });
+                const data = await response.json();
+                if (data.success) {
+                    const plan = data.plan;
+                    let result = `Refactor Plan Created\n${"=".repeat(50)}\n\n`;
+                    result += `Total files needing attention: ${plan.totalFiles}\n`;
+                    result += `  - Critical: ${plan.criticalCount}\n`;
+                    result += `  - Warning: ${plan.warningCount}\n\n`;
+                    if (plan.files.length > 0) {
+                        result += `Files:\n`;
+                        for (const file of plan.files) {
+                            const icon = file.severity === 'critical' ? '🔴' : '⚠️';
+                            result += `${icon} ${file.relativePath}\n`;
+                            result += `   Lines: ${file.lines}, Functions: ${file.functionCount}, Size: ${file.fileSize}KB\n`;
+                            if (file.suggestionCount > 0) {
+                                result += `   Suggestions: ${file.suggestionCount}\n`;
+                            }
+                        }
+                    }
+                    result += `\nPlan saved to .claudette/refactor-plan.json`;
+                    result += `\nUse get_refactor_plan to see detailed suggestions.`;
+                    return { content: [{ type: "text", text: result }] };
+                }
+                else {
+                    return { content: [{ type: "text", text: `Failed to create refactor plan: ${data.error}` }] };
+                }
+            }
+            catch (err) {
+                return { content: [{ type: "text", text: `Error creating refactor plan: ${err.message}` }] };
+            }
+        }
+        case "get_refactor_plan": {
+            const workspacePath = args?.workspace_path;
+            if (!workspacePath) {
+                return { content: [{ type: "text", text: "Error: workspace_path is required" }] };
+            }
+            try {
+                await logRefactorActivity(workspacePath, 'info', 'read_plan', 'Reading refactor plan...');
+                const response = await fetch(`${CLAUDETTE_API}/api/refactor/plan?path=${encodeURIComponent(workspacePath)}`);
+                if (response.status === 404) {
+                    return { content: [{ type: "text", text: "No refactor plan found. Use create_refactor_plan first." }] };
+                }
+                const plan = await response.json();
+                await logRefactorActivity(workspacePath, 'info', 'read_plan', `Plan loaded: ${plan.steps?.length || 0} steps, ${plan.totalFiles} files`, { totalFiles: plan.totalFiles, stepsCount: plan.steps?.length });
+                let result = `Refactor Plan\n${"=".repeat(50)}\n\n`;
+                result += `Workspace: ${plan.workspace}\n`;
+                result += `Created: ${plan.created}\n`;
+                result += `Status: ${plan.status}\n`;
+                // Show test framework and baseline info
+                if (plan.testFramework) {
+                    result += `Test Framework: ${plan.testFramework}${plan.hasTests ? '' : ' (not detected)'}\n`;
+                }
+                if (plan.baseline) {
+                    result += `Baseline: ${plan.baseline.passed} tests passing (captured ${plan.baseline.timestamp})\n`;
+                }
+                result += `\n`;
+                // Show steps if available
+                if (plan.steps && plan.steps.length > 0) {
+                    result += `REFACTORING STEPS\n${"─".repeat(40)}\n`;
+                    for (const step of plan.steps) {
+                        const status = step.completed ? '✅' : (step.id === plan.currentStep ? '▶️' : '⬜');
+                        result += `${status} Step ${step.id}: [${step.type}] ${step.description}\n`;
+                        if (step.file) {
+                            result += `   File: ${step.file}\n`;
+                        }
+                        if (step.targetFile) {
+                            result += `   Target: ${step.targetFile}\n`;
+                        }
+                        if (step.functions && step.functions.length > 0) {
+                            result += `   Functions: ${step.functions.slice(0, 5).join(', ')}${step.functions.length > 5 ? '...' : ''}\n`;
+                        }
+                    }
+                    result += `\n`;
+                }
+                result += `FILES NEEDING REFACTORING\n${"─".repeat(40)}\n`;
+                for (const file of plan.files) {
+                    const icon = file.severity === 'critical' ? '🔴 CRITICAL' : '⚠️ WARNING';
+                    result += `\n${icon}: ${file.relativePath}\n`;
+                    result += `Lines: ${file.lines} | Functions: ${file.functionCount} | Size: ${file.fileSize}KB\n`;
+                    if (file.suggestions && file.suggestions.length > 0) {
+                        for (const suggestion of file.suggestions) {
+                            result += `  📦 ${suggestion.description}\n`;
+                            result += `     → ${suggestion.targetFile}\n`;
+                        }
+                    }
+                }
+                result += `\n${"=".repeat(50)}\n`;
+                result += `WORKFLOW: Use get_next_refactor_step → do extraction → verify_refactor → complete_refactor_step\n`;
+                result += `After all steps complete, call complete_refactor to clean up.`;
+                return { content: [{ type: "text", text: result }] };
+            }
+            catch (err) {
+                return { content: [{ type: "text", text: `Error reading refactor plan: ${err.message}` }] };
+            }
+        }
+        case "complete_refactor": {
+            const workspacePath = args?.workspace_path;
+            if (!workspacePath) {
+                return { content: [{ type: "text", text: "Error: workspace_path is required" }] };
+            }
+            try {
+                const response = await fetch(`${CLAUDETTE_API}/api/refactor/plan?path=${encodeURIComponent(workspacePath)}`, {
+                    method: "DELETE",
+                });
+                const data = await response.json();
+                if (data.success) {
+                    return { content: [{ type: "text", text: "Refactoring complete! Plan file has been deleted." }] };
+                }
+                else {
+                    return { content: [{ type: "text", text: "No refactor plan found to delete." }] };
+                }
+            }
+            catch (err) {
+                return { content: [{ type: "text", text: `Error completing refactor: ${err.message}` }] };
+            }
+        }
+        case "verify_refactor": {
+            const workspacePath = args?.workspace_path;
+            if (!workspacePath) {
+                return { content: [{ type: "text", text: "Error: workspace_path is required" }] };
+            }
+            try {
+                await logRefactorActivity(workspacePath, 'info', 'verify', 'Running tests...');
+                const response = await fetch(`${CLAUDETTE_API}/api/refactor/verify`, {
+                    method: "POST",
+                    headers: { "Content-Type": "application/json" },
+                    body: JSON.stringify({ path: workspacePath }),
+                });
+                const result = await response.json();
+                // Log test results
+                await logRefactorActivity(workspacePath, result.success ? 'success' : 'error', 'verify', result.success
+                    ? `Tests passed: ${result.current?.passed}/${result.current?.total}`
+                    : `Tests failed: ${result.current?.failed} failures`, {
+                    testsPassed: result.current?.passed,
+                    testsFailed: result.current?.failed,
+                    testsTotal: result.current?.total,
+                });
+                let output = `Refactor Verification\n${"=".repeat(50)}\n\n`;
+                output += `${result.success ? '✅ PASSED' : '❌ FAILED'}\n\n`;
+                output += `${result.message}\n`;
+                if (result.current) {
+                    output += `\nCurrent Test Results:\n`;
+                    output += `  Passed: ${result.current.passed}\n`;
+                    output += `  Failed: ${result.current.failed}\n`;
+                    output += `  Total: ${result.current.total}\n`;
+                }
+                if (result.comparison) {
+                    output += `\nComparison to Baseline:\n`;
+                    if (result.comparison.passedDiff !== 0) {
+                        output += `  Passed: ${result.comparison.passedDiff > 0 ? '+' : ''}${result.comparison.passedDiff}\n`;
+                    }
+                    if (result.comparison.failedDiff !== 0) {
+                        output += `  Failed: ${result.comparison.failedDiff > 0 ? '+' : ''}${result.comparison.failedDiff}\n`;
+                    }
+                    if (result.comparison.newTests.length > 0) {
+                        output += `  New tests: ${result.comparison.newTests.length}\n`;
+                    }
+                    if (result.comparison.removedTests.length > 0) {
+                        output += `  Removed tests: ${result.comparison.removedTests.join(', ')}\n`;
+                    }
+                }
+                return { content: [{ type: "text", text: output }] };
+            }
+            catch (err) {
+                return { content: [{ type: "text", text: `Error verifying refactor: ${err.message}` }] };
+            }
+        }
+        case "complete_refactor_step": {
+            const workspacePath = args?.workspace_path;
+            const stepId = args?.step_id;
+            if (!workspacePath || stepId === undefined) {
+                return { content: [{ type: "text", text: "Error: workspace_path and step_id are required" }] };
+            }
+            try {
+                const response = await fetch(`${CLAUDETTE_API}/api/refactor/step/complete`, {
+                    method: "POST",
+                    headers: { "Content-Type": "application/json" },
+                    body: JSON.stringify({ path: workspacePath, stepId }),
+                });
+                const data = await response.json();
+                if (data.success) {
+                    await logRefactorActivity(workspacePath, 'success', 'complete_step', `Step ${stepId} completed`, { stepId });
+                    return { content: [{ type: "text", text: `Step ${stepId} marked as completed. Use get_next_refactor_step to see what's next.` }] };
+                }
+                else {
+                    return { content: [{ type: "text", text: `Failed to complete step: ${data.error}` }] };
+                }
+            }
+            catch (err) {
+                return { content: [{ type: "text", text: `Error completing step: ${err.message}` }] };
+            }
+        }
+        case "get_next_refactor_step": {
+            const workspacePath = args?.workspace_path;
+            if (!workspacePath) {
+                return { content: [{ type: "text", text: "Error: workspace_path is required" }] };
+            }
+            try {
+                const response = await fetch(`${CLAUDETTE_API}/api/refactor/step/next?path=${encodeURIComponent(workspacePath)}`);
+                const data = await response.json();
+                if (!data.hasNext) {
+                    await logRefactorActivity(workspacePath, 'success', 'all_complete', 'All refactoring steps completed!');
+                    return { content: [{ type: "text", text: "All refactoring steps completed! Use complete_refactor to clean up the plan." }] };
+                }
+                const step = data.step;
+                // Log step info with file details
+                await logRefactorActivity(workspacePath, 'step', 'next_step', `Step ${step.id}: ${step.description}`, { stepId: step.id, file: step.file });
+                let output = `Next Refactoring Step\n${"=".repeat(50)}\n\n`;
+                output += `Step ${step.id}: ${step.type.toUpperCase()}\n`;
+                output += `Description: ${step.description}\n`;
+                if (step.file) {
+                    output += `Source File: ${step.file}\n`;
+                }
+                if (step.targetFile) {
+                    output += `Target File: ${step.targetFile}\n`;
+                }
+                if (step.functions && step.functions.length > 0) {
+                    output += `Functions to extract:\n`;
+                    for (const fn of step.functions) {
+                        output += `  - ${fn}\n`;
+                    }
+                }
+                output += `\n${"─".repeat(40)}\n`;
+                if (step.type === 'verify_tests') {
+                    output += `ACTION: Run verify_refactor to check tests against baseline.`;
+                }
+                else if (step.type === 'extract_module') {
+                    output += `ACTION: Extract the listed functions to the target file, then run verify_refactor.`;
+                }
+                else if (step.type === 'verify_build') {
+                    output += `ACTION: Run build command and verify_refactor for final check.`;
+                }
+                output += `\nAfter completing, call complete_refactor_step with step_id=${step.id}`;
+                return { content: [{ type: "text", text: output }] };
+            }
+            catch (err) {
+                return { content: [{ type: "text", text: `Error getting next step: ${err.message}` }] };
+            }
+        }
+        case "run_tests": {
+            const workspacePath = args?.workspace_path;
+            const testFile = args?.test_file;
+            if (!workspacePath) {
+                return { content: [{ type: "text", text: "Error: workspace_path is required" }] };
+            }
+            try {
+                // Start the tests
+                const response = await fetch(`${CLAUDETTE_API}/api/jest/run`, {
+                    method: "POST",
+                    headers: { "Content-Type": "application/json" },
+                    body: JSON.stringify({ path: workspacePath, testFile }),
+                });
+                const data = await response.json();
+                if (!data.success) {
+                    return { content: [{ type: "text", text: `Failed to start tests: ${data.error}` }] };
+                }
+                // Wait for tests to complete (poll for results)
+                let attempts = 0;
+                const maxAttempts = 60; // 60 seconds max
+                while (attempts < maxAttempts) {
+                    await new Promise(resolve => setTimeout(resolve, 1000));
+                    attempts++;
+                    const statusRes = await fetch(`${CLAUDETTE_API}/api/jest/status?path=${encodeURIComponent(workspacePath)}`);
+                    const status = await statusRes.json();
+                    if (!status.isRunning && status.lastResult) {
+                        const result = status.lastResult;
+                        let output = `Test Results\n${"=".repeat(50)}\n\n`;
+                        output += `Status: ${result.numFailedTests === 0 ? "✅ PASSED" : "❌ FAILED"}\n`;
+                        output += `Suites: ${result.numPassedTestSuites}/${result.numTotalTestSuites} passed\n`;
+                        output += `Tests: ${result.numPassedTests}/${result.numTotalTests} passed\n`;
+                        if (result.numFailedTests > 0 && result.testResults) {
+                            output += `\nFailed Tests:\n`;
+                            for (const test of result.testResults) {
+                                if (test.status === 'failed') {
+                                    output += `\n❌ ${test.name}\n`;
+                                    if (test.failureMessages) {
+                                        output += test.failureMessages.join('\n');
+                                    }
+                                }
+                            }
+                        }
+                        return { content: [{ type: "text", text: output }] };
+                    }
+                }
+                return { content: [{ type: "text", text: "Tests are still running. Use get_test_results to check the results." }] };
+            }
+            catch (err) {
+                return { content: [{ type: "text", text: `Error running tests: ${err.message}` }] };
+            }
+        }
+        case "get_test_results": {
+            const workspacePath = args?.workspace_path;
+            if (!workspacePath) {
+                return { content: [{ type: "text", text: "Error: workspace_path is required" }] };
+            }
+            try {
+                const response = await fetch(`${CLAUDETTE_API}/api/jest/status?path=${encodeURIComponent(workspacePath)}`);
+                const status = await response.json();
+                if (status.isRunning) {
+                    return { content: [{ type: "text", text: "Tests are currently running..." }] };
+                }
+                if (!status.lastResult) {
+                    return { content: [{ type: "text", text: "No test results found. Run tests first with run_tests." }] };
+                }
+                const result = status.lastResult;
+                let output = `Test Results\n${"=".repeat(50)}\n\n`;
+                output += `Status: ${result.numFailedTests === 0 ? "✅ PASSED" : "❌ FAILED"}\n`;
+                output += `Suites: ${result.numPassedTestSuites}/${result.numTotalTestSuites} passed\n`;
+                output += `Tests: ${result.numPassedTests}/${result.numTotalTests} passed\n`;
+                if (result.testResults && result.testResults.length > 0) {
+                    output += `\nTest Details:\n`;
+                    for (const test of result.testResults) {
+                        const icon = test.status === 'passed' ? '✅' : '❌';
+                        output += `${icon} ${test.name} (${test.duration}ms)\n`;
+                        if (test.status === 'failed' && test.failureMessages) {
+                            output += `   ${test.failureMessages.join('\n   ')}\n`;
+                        }
+                    }
+                }
+                return { content: [{ type: "text", text: output }] };
+            }
+            catch (err) {
+                return { content: [{ type: "text", text: `Error getting test results: ${err.message}` }] };
+            }
+        }
         default:
             return { content: [{ type: "text", text: `Unknown tool: ${name}` }] };
     }