@azerate/claudette-mcp 1.2.0 → 1.4.0

package/README.md

@@ -1,16 +1,23 @@
 # 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
+MCP server for Claudette IDE - providing Claude with comprehensive workspace management tools.
+
+## Installation
+
+```bash
+npx @azerate/claudette-mcp
+```
+
+Or install globally:
+```bash
+npm install -g @azerate/claudette-mcp
+```
 
 ## Setup
 
 ### Option 1: Add via Claude Code CLI
 ```bash
-claude mcp add claudette node C:/repo/AzApp/mcp-server/dist/index.js
+claude mcp add claudette -- npx @azerate/claudette-mcp
 ```
 
 ### Option 2: Add to .mcp.json (project-level)
@@ -20,29 +27,135 @@ Create `.mcp.json` in your project root:
   "mcpServers": {
     "claudette": {
       "type": "stdio",
-      "command": "node",
-      "args": ["C:/repo/AzApp/mcp-server/dist/index.js"]
+      "command": "npx",
+      "args": ["@azerate/claudette-mcp"]
     }
   }
 }
 ```
 
 ### Option 3: Add to Claude Code settings
-Add to `~/.claude.json` under your project's `mcpServers`:
+Add to `~/.claude.json`:
 ```json
 "mcpServers": {
   "claudette": {
     "type": "stdio",
-    "command": "node",
-    "args": ["C:/repo/AzApp/mcp-server/dist/index.js"]
+    "command": "npx",
+    "args": ["@azerate/claudette-mcp"]
   }
 }
 ```
 
-## Usage
+## Available Tools
+
+### Code Quality
+
+| Tool | Description |
+|------|-------------|
+| `get_errors` | Get TypeScript compilation errors for the workspace |
+| `run_tests` | Run Jest tests and return results |
+| `get_test_results` | Get the latest test results |
+| `run_benchmarks` | Run performance benchmarks (tinybench/vitest) |
+| `get_benchmark_results` | Get the latest benchmark results |
+
+### Git & Changes
+
+| Tool | Description |
+|------|-------------|
+| `get_changes` | Get pending git changes (modified, added, deleted files) |
+| `get_checkpoints` | List saved checkpoints (git stash snapshots) |
+| `create_checkpoint` | Create a checkpoint before risky changes |
+| `restore_checkpoint` | Restore workspace to a previous checkpoint |
+| `delete_checkpoint` | Delete a checkpoint permanently |
+
+### Workflow Automation
+
+| Tool | Description |
+|------|-------------|
+| `get_workflow_status` | Get current workflow pipeline status |
+| `trigger_workflow` | Start the workflow (lint, types, tests, coverage, benchmarks) |
+| `generate_commit_message` | Generate a commit message from changes |
+| `approve_commit` | Stage and commit with the provided message |
+| `approve_push` | Push committed changes to remote |
+
+### Project Memory
+
+| Tool | Description |
+|------|-------------|
+| `get_memory` | Get project memory notes |
+| `add_memory` | Add a note to project memory |
+| `clear_memory` | Clear all project memory notes |
+| `delete_memory` | Delete specific notes by index |
+| `replace_memory` | Replace all memory with new notes |
+
+### Scripts & Automation
+
+| Tool | Description |
+|------|-------------|
+| `list_scripts` | List npm scripts and their status |
+| `run_script` | Start an npm script |
+| `stop_script` | Stop a running script |
+| `get_console_output` | Get console output from a script |
+| `check_quick_actions` | Check for pending UI-triggered actions |
+
+### Refactoring
+
+| Tool | Description |
+|------|-------------|
+| `create_refactor_plan` | Analyze workspace and create refactoring plan |
+| `get_refactor_plan` | Get the current refactor plan |
+| `get_next_refactor_step` | Get the next uncompleted step |
+| `verify_refactor` | Run tests and compare to baseline |
+| `complete_refactor_step` | Mark a step as completed |
+| `complete_refactor` | Finish refactoring and delete plan |
+
+## Workflow Pipeline
+
+The workflow feature provides a guided development process:
+
+```
+trigger_workflow()
+       |
+       v
+[AUTOMATIC]
+  1. Lint (with auto-fix)
+  2. Type checking
+  3. Run tests
+  4. Coverage analysis
+  5. Benchmarks (optional)
+       |
+       v
+[HUMAN GATES]
+  6. Review & Commit (approve_commit)
+  7. Push (approve_push)
+  8. Create PR
+```
+
+## Example Usage
+
+```
+# Check for errors
+get_errors(workspace_path="/path/to/project")
+
+# Run full workflow
+trigger_workflow(workspace_path="/path/to/project")
+
+# Check workflow status
+get_workflow_status(workspace_path="/path/to/project")
+
+# After checks pass, commit
+generate_commit_message(workspace_path="/path/to/project")
+approve_commit(workspace_path="/path/to/project", message="Add new feature")
+
+# Push changes
+approve_push(workspace_path="/path/to/project")
+```
+
+## Requirements
+
+- Node.js 18+
+- Claudette IDE server running on port 52001 (for full functionality)
+
+## License
 
-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
+MIT

package/dist/index.js

@@ -419,6 +419,108 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
                     required: ["workspace_path"],
                 },
             },
+            {
+                name: "run_benchmarks",
+                description: "Run performance benchmarks for the workspace. Returns benchmark results with ops/sec and timing data. Supports Tinybench, Vitest bench, and Benchmark.js.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        workspace_path: {
+                            type: "string",
+                            description: "Path to the workspace directory",
+                        },
+                    },
+                    required: ["workspace_path"],
+                },
+            },
+            {
+                name: "get_benchmark_results",
+                description: "Get the latest benchmark results for the workspace. Shows ops/sec, timing, and comparison data.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        workspace_path: {
+                            type: "string",
+                            description: "Path to the workspace directory",
+                        },
+                    },
+                    required: ["workspace_path"],
+                },
+            },
+            {
+                name: "get_workflow_status",
+                description: "Get the current workflow status for the workspace. Shows which checks have run (lint, types, tests, coverage, benchmarks) and git action status (commit, push, PR).",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        workspace_path: {
+                            type: "string",
+                            description: "Path to the workspace directory",
+                        },
+                    },
+                    required: ["workspace_path"],
+                },
+            },
+            {
+                name: "trigger_workflow",
+                description: "Start the development workflow pipeline. Runs automatic checks: lint (with auto-fix), type checking, tests, coverage analysis, and optionally benchmarks. The workflow pauses at git actions (commit, push, PR) for user approval.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        workspace_path: {
+                            type: "string",
+                            description: "Path to the workspace directory",
+                        },
+                    },
+                    required: ["workspace_path"],
+                },
+            },
+            {
+                name: "generate_commit_message",
+                description: "Generate a commit message based on the current git changes. Returns a suggested commit message.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        workspace_path: {
+                            type: "string",
+                            description: "Path to the workspace directory",
+                        },
+                    },
+                    required: ["workspace_path"],
+                },
+            },
+            {
+                name: "approve_commit",
+                description: "Stage all changes and create a git commit with the provided message. Use after workflow checks pass.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        workspace_path: {
+                            type: "string",
+                            description: "Path to the workspace directory",
+                        },
+                        message: {
+                            type: "string",
+                            description: "The commit message",
+                        },
+                    },
+                    required: ["workspace_path", "message"],
+                },
+            },
+            {
+                name: "approve_push",
+                description: "Push the committed changes to the remote repository.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        workspace_path: {
+                            type: "string",
+                            description: "Path to the workspace directory",
+                        },
+                    },
+                    required: ["workspace_path"],
+                },
+            },
         ],
     };
 });
@@ -904,6 +1006,15 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                 if (step.type === 'verify_tests') {
                     output += `ACTION: Run verify_refactor to check tests against baseline.`;
                 }
+                else if (step.type === 'write_tests') {
+                    output += `IMPORTANT: A test framework was just installed with only a placeholder test.\n`;
+                    output += `You MUST write real unit tests for the critical files listed above before proceeding.\n\n`;
+                    output += `For each file, create a corresponding test file (e.g., store.test.ts for store.tsx) that:\n`;
+                    output += `  1. Imports the main functions/components from the file\n`;
+                    output += `  2. Tests the core functionality with meaningful assertions\n`;
+                    output += `  3. Covers edge cases and error handling\n\n`;
+                    output += `After writing tests, run verify_refactor to establish a proper baseline.`;
+                }
                 else if (step.type === 'extract_module') {
                     output += `ACTION: Extract the listed functions to the target file, then run verify_refactor.`;
                 }
@@ -1003,6 +1114,233 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                 return { content: [{ type: "text", text: `Error getting test results: ${err.message}` }] };
             }
         }
+        case "run_benchmarks": {
+            const workspacePath = args?.workspace_path;
+            if (!workspacePath) {
+                return { content: [{ type: "text", text: "Error: workspace_path is required" }] };
+            }
+            try {
+                // Start the benchmarks
+                const response = await fetch(`${CLAUDETTE_API}/api/benchmarks/run`, {
+                    method: "POST",
+                    headers: { "Content-Type": "application/json" },
+                    body: JSON.stringify({ path: workspacePath, async: false }),
+                });
+                const data = await response.json();
+                if (!data.success) {
+                    return { content: [{ type: "text", text: `Failed to run benchmarks: ${data.error || data.results?.error}` }] };
+                }
+                const results = data.results;
+                let output = `Benchmark Results\n${"=".repeat(50)}\n\n`;
+                output += `Framework: ${results.framework}\n`;
+                output += `Total Benchmarks: ${results.totalBenchmarks}\n`;
+                output += `Duration: ${(results.duration / 1000).toFixed(2)}s\n\n`;
+                if (results.suites && results.suites.length > 0) {
+                    for (const suite of results.suites) {
+                        output += `📦 ${suite.name}\n`;
+                        for (const bench of suite.benchmarks) {
+                            const opsFormatted = bench.opsPerSecond >= 1e6
+                                ? `${(bench.opsPerSecond / 1e6).toFixed(2)}M`
+                                : bench.opsPerSecond >= 1e3
+                                    ? `${(bench.opsPerSecond / 1e3).toFixed(2)}K`
+                                    : bench.opsPerSecond.toFixed(2);
+                            output += `  ⚡ ${bench.name}: ${opsFormatted} ops/s (±${bench.margin.toFixed(1)}%)\n`;
+                        }
+                        output += '\n';
+                    }
+                }
+                return { content: [{ type: "text", text: output }] };
+            }
+            catch (err) {
+                return { content: [{ type: "text", text: `Error running benchmarks: ${err.message}` }] };
+            }
+        }
+        case "get_benchmark_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/benchmarks/status?path=${encodeURIComponent(workspacePath)}`);
+                const status = await response.json();
+                if (status.isRunning) {
+                    return { content: [{ type: "text", text: "Benchmarks are currently running..." }] };
+                }
+                if (!status.lastResult) {
+                    return { content: [{ type: "text", text: "No benchmark results found. Run benchmarks first with run_benchmarks." }] };
+                }
+                const results = status.lastResult;
+                let output = `Benchmark Results\n${"=".repeat(50)}\n\n`;
+                output += `Framework: ${results.framework}\n`;
+                output += `Status: ${results.success ? "✅ SUCCESS" : "❌ FAILED"}\n`;
+                output += `Total Benchmarks: ${results.totalBenchmarks}\n`;
+                output += `Duration: ${(results.duration / 1000).toFixed(2)}s\n`;
+                output += `Timestamp: ${results.timestamp}\n\n`;
+                if (results.error) {
+                    output += `Error: ${results.error}\n\n`;
+                }
+                if (results.suites && results.suites.length > 0) {
+                    output += `Benchmark Details:\n${"─".repeat(40)}\n`;
+                    for (const suite of results.suites) {
+                        output += `\n📦 ${suite.name} (${suite.benchmarks.length} benchmarks)\n`;
+                        for (const bench of suite.benchmarks) {
+                            const opsFormatted = bench.opsPerSecond >= 1e6
+                                ? `${(bench.opsPerSecond / 1e6).toFixed(2)}M`
+                                : bench.opsPerSecond >= 1e3
+                                    ? `${(bench.opsPerSecond / 1e3).toFixed(2)}K`
+                                    : bench.opsPerSecond.toFixed(2);
+                            output += `  ⚡ ${bench.name}\n`;
+                            output += `     ${opsFormatted} ops/s | avg: ${bench.avgTime.toFixed(4)}ms | ±${bench.margin.toFixed(1)}%\n`;
+                        }
+                    }
+                }
+                return { content: [{ type: "text", text: output }] };
+            }
+            catch (err) {
+                return { content: [{ type: "text", text: `Error getting benchmark results: ${err.message}` }] };
+            }
+        }
+        case "get_workflow_status": {
+            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/workflow/status?path=${encodeURIComponent(workspacePath)}`);
+                const status = await response.json();
+                let output = `Workflow Status\n${"=".repeat(50)}\n\n`;
+                output += `Current Step: ${status.currentStep}\n`;
+                output += `Running: ${status.isRunning ? "Yes" : "No"}\n`;
+                output += `Changed Files: ${status.changedFiles?.length || 0}\n\n`;
+                output += `Automatic Checks:\n${"─".repeat(40)}\n`;
+                const checkSteps = ['lint', 'types', 'tests', 'coverage', 'benchmarks'];
+                for (const step of checkSteps) {
+                    const result = status.steps[step];
+                    const icon = result.status === 'passed' ? '✅' :
+                        result.status === 'failed' ? '❌' :
+                            result.status === 'warning' ? '⚠️' :
+                                result.status === 'running' ? '🔄' :
+                                    result.status === 'skipped' ? '⏭️' : '⏸️';
+                    let info = '';
+                    if (step === 'lint' && result.fixed)
+                        info = ` (${result.fixed} fixed)`;
+                    if (step === 'types' && result.typeErrors)
+                        info = ` (${result.typeErrors} errors)`;
+                    if (step === 'tests' && result.passed !== undefined)
+                        info = ` (${result.passed}/${result.total})`;
+                    if (step === 'coverage' && result.percent !== undefined)
+                        info = ` (${result.percent}%)`;
+                    output += `${icon} ${step}${info}\n`;
+                }
+                output += `\nGit Actions:\n${"─".repeat(40)}\n`;
+                const gitSteps = ['commit', 'push', 'pr'];
+                for (const step of gitSteps) {
+                    const result = status.steps[step];
+                    const icon = result.status === 'passed' ? '✅' :
+                        result.status === 'pending' ? '⏸️' : '❓';
+                    output += `${icon} ${step}\n`;
+                }
+                if (status.error) {
+                    output += `\n❌ Error: ${status.error}\n`;
+                }
+                return { content: [{ type: "text", text: output }] };
+            }
+            catch (err) {
+                return { content: [{ type: "text", text: `Error getting workflow status: ${err.message}` }] };
+            }
+        }
+        case "trigger_workflow": {
+            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/workflow/trigger`, {
+                    method: "POST",
+                    headers: { "Content-Type": "application/json" },
+                    body: JSON.stringify({ path: workspacePath }),
+                });
+                const status = await response.json();
+                let output = `Workflow triggered successfully!\n\n`;
+                output += `Current Step: ${status.currentStep}\n`;
+                output += `Changed Files: ${status.changedFiles?.length || 0}\n\n`;
+                output += `The workflow will run these checks automatically:\n`;
+                output += `1. Lint (with auto-fix)\n`;
+                output += `2. Type checking\n`;
+                output += `3. Tests\n`;
+                output += `4. Coverage analysis\n`;
+                output += `5. Benchmarks (optional)\n\n`;
+                output += `Use get_workflow_status to monitor progress.`;
+                return { content: [{ type: "text", text: output }] };
+            }
+            catch (err) {
+                return { content: [{ type: "text", text: `Error triggering workflow: ${err.message}` }] };
+            }
+        }
+        case "generate_commit_message": {
+            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/workflow/commit-message?path=${encodeURIComponent(workspacePath)}`);
+                const data = await response.json();
+                return { content: [{ type: "text", text: `Suggested commit message:\n\n${data.message}` }] };
+            }
+            catch (err) {
+                return { content: [{ type: "text", text: `Error generating commit message: ${err.message}` }] };
+            }
+        }
+        case "approve_commit": {
+            const workspacePath = args?.workspace_path;
+            const message = args?.message;
+            if (!workspacePath) {
+                return { content: [{ type: "text", text: "Error: workspace_path is required" }] };
+            }
+            if (!message) {
+                return { content: [{ type: "text", text: "Error: message is required" }] };
+            }
+            try {
+                const response = await fetch(`${CLAUDETTE_API}/api/workflow/commit`, {
+                    method: "POST",
+                    headers: { "Content-Type": "application/json" },
+                    body: JSON.stringify({ path: workspacePath, message }),
+                });
+                const result = await response.json();
+                if (result.status === 'passed') {
+                    return { content: [{ type: "text", text: `✅ Commit created successfully!\n\nMessage: ${result.message}\nFiles committed: ${result.filesCommitted}` }] };
+                }
+                else {
+                    return { content: [{ type: "text", text: `❌ Commit failed: ${result.error}` }] };
+                }
+            }
+            catch (err) {
+                return { content: [{ type: "text", text: `Error creating commit: ${err.message}` }] };
+            }
+        }
+        case "approve_push": {
+            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/workflow/push`, {
+                    method: "POST",
+                    headers: { "Content-Type": "application/json" },
+                    body: JSON.stringify({ path: workspacePath }),
+                });
+                const result = await response.json();
+                if (result.status === 'passed') {
+                    return { content: [{ type: "text", text: `✅ Push successful!\n\nBranch: ${result.branch}\nRemote: ${result.remote}` }] };
+                }
+                else {
+                    return { content: [{ type: "text", text: `❌ Push failed: ${result.error}` }] };
+                }
+            }
+            catch (err) {
+                return { content: [{ type: "text", text: `Error pushing changes: ${err.message}` }] };
+            }
+        }
         default:
             return { content: [{ type: "text", text: `Unknown tool: ${name}` }] };
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@azerate/claudette-mcp",
-  "version": "1.2.0",
+  "version": "1.4.0",
   "description": "MCP server for Claudette IDE - TypeScript errors, git changes, checkpoints, memory, and script management",
   "type": "module",
   "main": "dist/index.js",