@azerate/claudette-mcp 1.0.0

package/README.md

@@ -0,0 +1,48 @@
+# Claudette MCP Server
+
+Provides Claude with direct access to:
+- **get_errors** - Check TypeScript/ESLint errors
+- **get_changes** - See pending git changes
+- **get_memory** - Read project memory notes
+- **add_memory** - Add notes to project memory
+
+## Setup
+
+### Option 1: Add via Claude Code CLI
+```bash
+claude mcp add claudette node C:/repo/AzApp/mcp-server/dist/index.js
+```
+
+### Option 2: Add to .mcp.json (project-level)
+Create `.mcp.json` in your project root:
+```json
+{
+  "mcpServers": {
+    "claudette": {
+      "type": "stdio",
+      "command": "node",
+      "args": ["C:/repo/AzApp/mcp-server/dist/index.js"]
+    }
+  }
+}
+```
+
+### Option 3: Add to Claude Code settings
+Add to `~/.claude.json` under your project's `mcpServers`:
+```json
+"mcpServers": {
+  "claudette": {
+    "type": "stdio",
+    "command": "node",
+    "args": ["C:/repo/AzApp/mcp-server/dist/index.js"]
+  }
+}
+```
+
+## Usage
+
+Once configured, Claude will have access to these tools:
+- `get_errors` - Pass workspace_path to check for TypeScript errors
+- `get_changes` - Pass workspace_path to see git status
+- `get_memory` - Pass workspace_path to read project notes
+- `add_memory` - Pass workspace_path and note to save a note

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,890 @@
+#!/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";
+import { execSync } from "child_process";
+import { existsSync, readFileSync, writeFileSync, mkdirSync, unlinkSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+// 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) {
+    try {
+        execSync(`git stash drop ${id}`, {
+            cwd: workspacePath,
+            encoding: "utf-8",
+        });
+        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
+    }
+    return changes;
+}
+// Create the MCP server
+const server = new Server({
+    name: "claudette-mcp",
+    version: "1.0.0",
+}, {
+    capabilities: {
+        tools: {},
+    },
+});
+// List available tools
+server.setRequestHandler(ListToolsRequestSchema, async () => {
+    return {
+        tools: [
+            {
+                name: "get_errors",
+                description: "Get TypeScript compilation errors for the current workspace. Returns a list of errors with file, line, column, and message.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        workspace_path: {
+                            type: "string",
+                            description: "Path to the workspace directory",
+                        },
+                    },
+                    required: ["workspace_path"],
+                },
+            },
+            {
+                name: "get_changes",
+                description: "Get pending git changes (modified, added, deleted files) for the workspace. Shows both staged and unstaged changes.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        workspace_path: {
+                            type: "string",
+                            description: "Path to the workspace directory",
+                        },
+                    },
+                    required: ["workspace_path"],
+                },
+            },
+            {
+                name: "get_memory",
+                description: "Get project memory notes for the workspace. These are persistent notes about the project.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        workspace_path: {
+                            type: "string",
+                            description: "Path to the workspace directory",
+                        },
+                    },
+                    required: ["workspace_path"],
+                },
+            },
+            {
+                name: "add_memory",
+                description: "Add a note to project memory. Use this to remember important things about the project.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        workspace_path: {
+                            type: "string",
+                            description: "Path to the workspace directory",
+                        },
+                        note: {
+                            type: "string",
+                            description: "The note to add to project memory",
+                        },
+                    },
+                    required: ["workspace_path", "note"],
+                },
+            },
+            {
+                name: "get_checkpoints",
+                description: "Get all saved checkpoints (snapshots) for the workspace. Checkpoints allow reverting to previous states.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        workspace_path: {
+                            type: "string",
+                            description: "Path to the workspace directory",
+                        },
+                    },
+                    required: ["workspace_path"],
+                },
+            },
+            {
+                name: "create_checkpoint",
+                description: "Create a checkpoint (snapshot) of current changes. Use before making risky changes.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        workspace_path: {
+                            type: "string",
+                            description: "Path to the workspace directory",
+                        },
+                        message: {
+                            type: "string",
+                            description: "Optional name for the checkpoint. Auto-generates from changes if not provided.",
+                        },
+                    },
+                    required: ["workspace_path"],
+                },
+            },
+            {
+                name: "restore_checkpoint",
+                description: "Restore workspace to a previous checkpoint. Current changes are auto-saved first.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        workspace_path: {
+                            type: "string",
+                            description: "Path to the workspace directory",
+                        },
+                        checkpoint_id: {
+                            type: "string",
+                            description: "The checkpoint ID to restore (e.g., 'stash@{0}')",
+                        },
+                    },
+                    required: ["workspace_path", "checkpoint_id"],
+                },
+            },
+            {
+                name: "delete_checkpoint",
+                description: "Delete a checkpoint permanently.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        workspace_path: {
+                            type: "string",
+                            description: "Path to the workspace directory",
+                        },
+                        checkpoint_id: {
+                            type: "string",
+                            description: "The checkpoint ID to delete (e.g., 'stash@{0}')",
+                        },
+                    },
+                    required: ["workspace_path", "checkpoint_id"],
+                },
+            },
+            {
+                name: "list_scripts",
+                description: "List all npm scripts available in the workspace and their current status (running/stopped).",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        workspace_path: {
+                            type: "string",
+                            description: "Path to the workspace directory",
+                        },
+                    },
+                    required: ["workspace_path"],
+                },
+            },
+            {
+                name: "get_console_output",
+                description: "Get the console output from a running or recently run script. Useful for checking dev server logs, build output, or error messages.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        workspace_path: {
+                            type: "string",
+                            description: "Path to the workspace directory",
+                        },
+                        script_name: {
+                            type: "string",
+                            description: "Name of the script (e.g., 'dev', 'build', 'test')",
+                        },
+                    },
+                    required: ["workspace_path", "script_name"],
+                },
+            },
+            {
+                name: "run_script",
+                description: "Start an npm script in the workspace. For dev scripts, this will auto-launch Chrome with DevTools.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        workspace_path: {
+                            type: "string",
+                            description: "Path to the workspace directory",
+                        },
+                        script_name: {
+                            type: "string",
+                            description: "Name of the script to run (e.g., 'dev', 'build', 'test')",
+                        },
+                    },
+                    required: ["workspace_path", "script_name"],
+                },
+            },
+            {
+                name: "stop_script",
+                description: "Stop a running npm script in the workspace.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        workspace_path: {
+                            type: "string",
+                            description: "Path to the workspace directory",
+                        },
+                        script_name: {
+                            type: "string",
+                            description: "Name of the script to stop",
+                        },
+                    },
+                    required: ["workspace_path", "script_name"],
+                },
+            },
+            {
+                name: "check_quick_actions",
+                description: "Check for pending quick actions from Claudette IDE. Call this when the user asks you to check for actions or when you want to see if there are any UI-triggered tasks.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        workspace_path: {
+                            type: "string",
+                            description: "Path to the workspace directory",
+                        },
+                    },
+                    required: ["workspace_path"],
+                },
+            },
+        ],
+    };
+});
+// Handle tool calls
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+    switch (name) {
+        case "get_errors": {
+            const workspacePath = args?.workspace_path;
+            if (!workspacePath) {
+                return { content: [{ type: "text", text: "Error: workspace_path is required" }] };
+            }
+            const errors = getTypeScriptErrors(workspacePath);
+            if (errors.length === 0) {
+                return { content: [{ type: "text", text: "No TypeScript errors found." }] };
+            }
+            const summary = `Found ${errors.length} error(s):\n\n` +
+                errors.map(e => `${e.file}:${e.line}:${e.column} - ${e.severity} ${e.code}: ${e.message}`).join("\n");
+            return { content: [{ type: "text", text: summary }] };
+        }
+        case "get_changes": {
+            const workspacePath = args?.workspace_path;
+            if (!workspacePath) {
+                return { content: [{ type: "text", text: "Error: workspace_path is required" }] };
+            }
+            const changes = getGitChanges(workspacePath);
+            if (changes.length === 0) {
+                return { content: [{ type: "text", text: "No pending git changes." }] };
+            }
+            const staged = changes.filter(c => c.staged);
+            const unstaged = changes.filter(c => !c.staged);
+            let summary = `Git Changes:\n\n`;
+            if (staged.length > 0) {
+                summary += `Staged (${staged.length}):\n`;
+                summary += staged.map(c => `  [${c.status}] ${c.file}`).join("\n");
+                summary += "\n\n";
+            }
+            if (unstaged.length > 0) {
+                summary += `Unstaged (${unstaged.length}):\n`;
+                summary += unstaged.map(c => `  [${c.status}] ${c.file}`).join("\n");
+            }
+            return { content: [{ type: "text", text: summary }] };
+        }
+        case "get_memory": {
+            const workspacePath = args?.workspace_path;
+            if (!workspacePath) {
+                return { content: [{ type: "text", text: "Error: workspace_path is required" }] };
+            }
+            const config = getWorkspaceConfig(workspacePath);
+            const memory = config?.memory || [];
+            if (memory.length === 0) {
+                return { content: [{ type: "text", text: "No project memory notes yet." }] };
+            }
+            return { content: [{ type: "text", text: `Project Memory:\n\n${memory.join("\n\n")}` }] };
+        }
+        case "add_memory": {
+            const workspacePath = args?.workspace_path;
+            const note = args?.note;
+            if (!workspacePath || !note) {
+                return { content: [{ type: "text", text: "Error: workspace_path and note are required" }] };
+            }
+            let config = getWorkspaceConfig(workspacePath);
+            if (!config) {
+                config = {
+                    name: workspacePath.split(/[/\\]/).pop() || "workspace",
+                    path: workspacePath,
+                    configured: false,
+                    memory: [],
+                };
+            }
+            const timestamp = new Date().toLocaleString();
+            config.memory.push(`[${timestamp}] ${note}`);
+            saveWorkspaceConfig(config);
+            return { content: [{ type: "text", text: `Added to project memory: "${note}"` }] };
+        }
+        case "get_checkpoints": {
+            const workspacePath = args?.workspace_path;
+            if (!workspacePath) {
+                return { content: [{ type: "text", text: "Error: workspace_path is required" }] };
+            }
+            const checkpoints = getCheckpoints(workspacePath);
+            if (checkpoints.length === 0) {
+                return { content: [{ type: "text", text: "No checkpoints saved." }] };
+            }
+            const summary = `Found ${checkpoints.length} checkpoint(s):\n\n` +
+                checkpoints.map((c, i) => `${i + 1}. [${c.id}] ${c.message} (${c.filesChanged} files, ${c.timestamp})`).join("\n");
+            return { content: [{ type: "text", text: summary }] };
+        }
+        case "create_checkpoint": {
+            const workspacePath = args?.workspace_path;
+            const message = args?.message;
+            if (!workspacePath) {
+                return { content: [{ type: "text", text: "Error: workspace_path is required" }] };
+            }
+            const result = createCheckpoint(workspacePath, message);
+            if (result.success) {
+                return { content: [{ type: "text", text: "Checkpoint created successfully." }] };
+            }
+            else {
+                return { content: [{ type: "text", text: `Failed to create checkpoint: ${result.error}` }] };
+            }
+        }
+        case "restore_checkpoint": {
+            const workspacePath = args?.workspace_path;
+            const checkpointId = args?.checkpoint_id;
+            if (!workspacePath || !checkpointId) {
+                return { content: [{ type: "text", text: "Error: workspace_path and checkpoint_id are required" }] };
+            }
+            const result = restoreCheckpoint(workspacePath, checkpointId);
+            if (result.success) {
+                return { content: [{ type: "text", text: `Restored to checkpoint ${checkpointId}. Your previous changes were auto-saved.` }] };
+            }
+            else {
+                return { content: [{ type: "text", text: `Failed to restore checkpoint: ${result.error}` }] };
+            }
+        }
+        case "delete_checkpoint": {
+            const workspacePath = args?.workspace_path;
+            const checkpointId = args?.checkpoint_id;
+            if (!workspacePath || !checkpointId) {
+                return { content: [{ type: "text", text: "Error: workspace_path and checkpoint_id are required" }] };
+            }
+            const result = deleteCheckpoint(workspacePath, checkpointId);
+            if (result.success) {
+                return { content: [{ type: "text", text: `Deleted checkpoint ${checkpointId}.` }] };
+            }
+            else {
+                return { content: [{ type: "text", text: `Failed to delete checkpoint: ${result.error}` }] };
+            }
+        }
+        case "list_scripts": {
+            const workspacePath = args?.workspace_path;
+            if (!workspacePath) {
+                return { content: [{ type: "text", text: "Error: workspace_path is required" }] };
+            }
+            const data = await getScripts(workspacePath);
+            if (!data.hasPackageJson) {
+                return { content: [{ type: "text", text: "No package.json found in workspace." }] };
+            }
+            if (data.scripts.length === 0) {
+                return { content: [{ type: "text", text: "No scripts defined in package.json." }] };
+            }
+            const scriptList = data.scripts.map(s => {
+                const statusIcon = s.status === 'running' ? '🟢' : s.status === 'error' ? '🔴' : '⚪';
+                return `${statusIcon} ${s.name}: ${s.command}${s.status === 'running' ? ' (RUNNING)' : ''}`;
+            }).join('\n');
+            return { content: [{ type: "text", text: `Scripts in workspace:\n\n${scriptList}` }] };
+        }
+        case "get_console_output": {
+            const workspacePath = args?.workspace_path;
+            const scriptName = args?.script_name;
+            if (!workspacePath || !scriptName) {
+                return { content: [{ type: "text", text: "Error: workspace_path and script_name are required" }] };
+            }
+            const output = await getScriptOutput(workspacePath, scriptName);
+            if (output === null) {
+                return { content: [{ type: "text", text: `No output found for script "${scriptName}". The script may not have been run yet.` }] };
+            }
+            if (!output.trim()) {
+                return { content: [{ type: "text", text: `Script "${scriptName}" has no output yet.` }] };
+            }
+            // Limit output to last 200 lines to avoid overwhelming Claude
+            const lines = output.split('\n');
+            const limitedOutput = lines.slice(-200).join('\n');
+            const truncated = lines.length > 200 ? `(Showing last 200 of ${lines.length} lines)\n\n` : '';
+            return { content: [{ type: "text", text: `Console output for "${scriptName}":\n\n${truncated}${limitedOutput}` }] };
+        }
+        case "run_script": {
+            const workspacePath = args?.workspace_path;
+            const scriptName = args?.script_name;
+            if (!workspacePath || !scriptName) {
+                return { content: [{ type: "text", text: "Error: workspace_path and script_name are required" }] };
+            }
+            const result = await startScript(workspacePath, scriptName);
+            if (result.success) {
+                return { content: [{ type: "text", text: `Started script "${scriptName}". Use get_console_output to check the output.` }] };
+            }
+            else {
+                return { content: [{ type: "text", text: `Failed to start script: ${result.error}` }] };
+            }
+        }
+        case "stop_script": {
+            const workspacePath = args?.workspace_path;
+            const scriptName = args?.script_name;
+            if (!workspacePath || !scriptName) {
+                return { content: [{ type: "text", text: "Error: workspace_path and script_name are required" }] };
+            }
+            const result = await stopScript(workspacePath, scriptName);
+            if (result.success) {
+                return { content: [{ type: "text", text: `Stopped script "${scriptName}".` }] };
+            }
+            else {
+                return { content: [{ type: "text", text: `Failed to stop script: ${result.error}` }] };
+            }
+        }
+        case "check_quick_actions": {
+            const workspacePath = args?.workspace_path;
+            if (!workspacePath) {
+                return { content: [{ type: "text", text: "Error: workspace_path is required" }] };
+            }
+            const pending = getPendingAction(workspacePath);
+            if (pending) {
+                return {
+                    content: [{
+                            type: "text",
+                            text: `[CLAUDETTE QUICK ACTION]\n\nThe user clicked a quick action button in Claudette IDE. Please execute the following request:\n\n${pending.prompt}\n\n(Action type: ${pending.action || 'custom'})`
+                        }]
+                };
+            }
+            else {
+                return { content: [{ type: "text", text: "No pending quick actions from Claudette IDE." }] };
+            }
+        }
+        default:
+            return { content: [{ type: "text", text: `Unknown tool: ${name}` }] };
+    }
+});
+// Start the server
+async function main() {
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error("Claudette MCP server running on stdio");
+}
+main().catch(console.error);

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "@azerate/claudette-mcp",
+  "version": "1.0.0",
+  "description": "MCP server for Claudette IDE - TypeScript errors, git changes, checkpoints, memory, and script management",
+  "type": "module",
+  "main": "dist/index.js",
+  "bin": {
+    "claudette-mcp": "dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "start": "node dist/index.js",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "mcp",
+    "claude",
+    "claudette",
+    "typescript",
+    "git",
+    "ide"
+  ],
+  "author": "azerate",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/azerate/claudette"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "typescript": "^5.7.0"
+  }
+}