@azerate/claudette-mcp 1.4.0 → 1.6.0

package/README.md

@@ -63,6 +63,9 @@ Add to `~/.claude.json`:
 | Tool | Description |
 |------|-------------|
 | `get_changes` | Get pending git changes (modified, added, deleted files) |
+| `get_branch_info` | Get current branch, behind/ahead status, sync state |
+| `create_branch` | Create a new feature branch from main/master |
+| `sync_branch` | Rebase or merge current branch with main |
 | `get_checkpoints` | List saved checkpoints (git stash snapshots) |
 | `create_checkpoint` | Create a checkpoint before risky changes |
 | `restore_checkpoint` | Restore workspace to a previous checkpoint |
@@ -77,6 +80,9 @@ Add to `~/.claude.json`:
 | `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 |
+| `approve_write_tests` | Mark the write tests step as complete |
+| `create_pr` | Create a pull request using gh CLI |
+| `approve_code_review` | Mark the code review step as complete |
 
 ### Project Memory
 
@@ -111,26 +117,46 @@ Add to `~/.claude.json`:
 
 ## Workflow Pipeline
 
-The workflow feature provides a guided development process:
+The workflow feature provides a 10-step guided development process with best-practice Git support:
 
 ```
 trigger_workflow()
        |
        v
-[AUTOMATIC]
-  1. Lint (with auto-fix)
-  2. Type checking
+[AUTOMATIC CHECKS]
+  1. Type checking (tsc --noEmit)
+  2. Lint/Format (eslint --fix)
   3. Run tests
-  4. Coverage analysis
+  4. Coverage analysis (files needing tests)
   5. Benchmarks (optional)
        |
        v
 [HUMAN GATES]
-  6. Review & Commit (approve_commit)
-  7. Push (approve_push)
-  8. Create PR
+  6. Write Tests (if coverage found gaps)
+  7. Commit (approve_commit)
+  8. Push (approve_push)
+  9. Create PR (skipped if on main)
+  10. Code Review (approve_code_review)
 ```
 
+### Branch Management
+
+Best practice: Work on feature branches, not directly on main.
+
+```
+# Check current branch status
+get_branch_info(workspace_path="/path/to/project")
+
+# Create a feature branch
+create_branch(workspace_path="/path/to/project", branch_name="feature/my-feature")
+
+# Sync with latest main (rebase)
+sync_branch(workspace_path="/path/to/project", method="rebase")
+```
+
+The workflow enforces feature branch usage by default (`requireFeatureBranch: true`).
+Toggle this in the UI or set in `.claudette/workflow-config.json`.
+
 ## Example Usage
 
 ```

package/dist/index.js

@@ -521,6 +521,119 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
                     required: ["workspace_path"],
                 },
             },
+            {
+                name: "approve_write_tests",
+                description: "Mark the write tests step as complete after tests have been written for uncovered files.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        workspace_path: {
+                            type: "string",
+                            description: "Path to the workspace directory",
+                        },
+                        tests_written: {
+                            type: "number",
+                            description: "Number of test files written",
+                        },
+                    },
+                    required: ["workspace_path", "tests_written"],
+                },
+            },
+            {
+                name: "approve_code_review",
+                description: "Mark the code review step as complete after the PR has been reviewed and approved.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        workspace_path: {
+                            type: "string",
+                            description: "Path to the workspace directory",
+                        },
+                        reviewer: {
+                            type: "string",
+                            description: "Name of the reviewer (optional)",
+                        },
+                    },
+                    required: ["workspace_path"],
+                },
+            },
+            {
+                name: "create_pr",
+                description: "Create a pull request for the current branch. Uses gh CLI to create the PR and updates workflow status.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        workspace_path: {
+                            type: "string",
+                            description: "Path to the workspace directory",
+                        },
+                        title: {
+                            type: "string",
+                            description: "PR title",
+                        },
+                        body: {
+                            type: "string",
+                            description: "PR description/body",
+                        },
+                    },
+                    required: ["workspace_path", "title"],
+                },
+            },
+            {
+                name: "get_branch_info",
+                description: "Get current git branch information including branch name, whether it's main/master, and behind/ahead counts relative to origin and main branch.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        workspace_path: {
+                            type: "string",
+                            description: "Path to the workspace directory",
+                        },
+                        fetch: {
+                            type: "boolean",
+                            description: "Whether to fetch from remote first (slower but more accurate). Default: false",
+                        },
+                    },
+                    required: ["workspace_path"],
+                },
+            },
+            {
+                name: "create_branch",
+                description: "Create a new feature branch from main/master. Best practice: always create feature branches for new work instead of committing directly to main.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        workspace_path: {
+                            type: "string",
+                            description: "Path to the workspace directory",
+                        },
+                        branch_name: {
+                            type: "string",
+                            description: "Name for the new branch (e.g., 'feature/add-login', 'fix/button-alignment')",
+                        },
+                    },
+                    required: ["workspace_path", "branch_name"],
+                },
+            },
+            {
+                name: "sync_branch",
+                description: "Sync current branch with main/master by rebasing or merging. Use when your branch is behind main to incorporate latest changes.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        workspace_path: {
+                            type: "string",
+                            description: "Path to the workspace directory",
+                        },
+                        method: {
+                            type: "string",
+                            enum: ["rebase", "merge"],
+                            description: "Sync method: 'rebase' (cleaner history, default) or 'merge' (preserves branch history)",
+                        },
+                    },
+                    required: ["workspace_path"],
+                },
+            },
         ],
     };
 });
@@ -1341,6 +1454,184 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                 return { content: [{ type: "text", text: `Error pushing changes: ${err.message}` }] };
             }
         }
+        case "approve_write_tests": {
+            const workspacePath = args?.workspace_path;
+            const testsWritten = args?.tests_written;
+            if (!workspacePath) {
+                return { content: [{ type: "text", text: "Error: workspace_path is required" }] };
+            }
+            if (testsWritten === undefined) {
+                return { content: [{ type: "text", text: "Error: tests_written is required" }] };
+            }
+            try {
+                const response = await fetch(`${CLAUDETTE_API}/api/workflow/write-tests`, {
+                    method: "POST",
+                    headers: { "Content-Type": "application/json" },
+                    body: JSON.stringify({ path: workspacePath, testsWritten }),
+                });
+                const result = await response.json();
+                if (result.status === 'passed') {
+                    return { content: [{ type: "text", text: `✅ Write tests step complete!\n\nTests written: ${result.testsWritten}\n\nWorkflow advanced to commit stage.` }] };
+                }
+                else {
+                    return { content: [{ type: "text", text: `❌ Failed: ${result.error}` }] };
+                }
+            }
+            catch (err) {
+                return { content: [{ type: "text", text: `Error: ${err.message}` }] };
+            }
+        }
+        case "approve_code_review": {
+            const workspacePath = args?.workspace_path;
+            const reviewer = args?.reviewer;
+            if (!workspacePath) {
+                return { content: [{ type: "text", text: "Error: workspace_path is required" }] };
+            }
+            try {
+                const response = await fetch(`${CLAUDETTE_API}/api/workflow/code-review`, {
+                    method: "POST",
+                    headers: { "Content-Type": "application/json" },
+                    body: JSON.stringify({ path: workspacePath, reviewer }),
+                });
+                const result = await response.json();
+                if (result.status === 'passed') {
+                    return { content: [{ type: "text", text: `✅ Code review approved!\n\n${result.reviewer ? `Reviewer: ${result.reviewer}\n` : ''}Workflow complete.` }] };
+                }
+                else {
+                    return { content: [{ type: "text", text: `❌ Failed: ${result.error}` }] };
+                }
+            }
+            catch (err) {
+                return { content: [{ type: "text", text: `Error: ${err.message}` }] };
+            }
+        }
+        case "create_pr": {
+            const workspacePath = args?.workspace_path;
+            const title = args?.title;
+            const body = args?.body ?? '';
+            if (!workspacePath) {
+                return { content: [{ type: "text", text: "Error: workspace_path is required" }] };
+            }
+            if (!title) {
+                return { content: [{ type: "text", text: "Error: title is required" }] };
+            }
+            try {
+                const response = await fetch(`${CLAUDETTE_API}/api/workflow/pr`, {
+                    method: "POST",
+                    headers: { "Content-Type": "application/json" },
+                    body: JSON.stringify({ path: workspacePath, title, body }),
+                });
+                const result = await response.json();
+                if (result.status === 'passed' || result.url) {
+                    return { content: [{ type: "text", text: `✅ Pull Request created!\n\nURL: ${result.url}\nPR #${result.prNumber}\n\nWorkflow advanced to code review.` }] };
+                }
+                else {
+                    return { content: [{ type: "text", text: `❌ Failed to create PR: ${result.error}` }] };
+                }
+            }
+            catch (err) {
+                return { content: [{ type: "text", text: `Error: ${err.message}` }] };
+            }
+        }
+        case "get_branch_info": {
+            const workspacePath = args?.workspace_path;
+            const doFetch = args?.fetch ?? false;
+            if (!workspacePath) {
+                return { content: [{ type: "text", text: "Error: workspace_path is required" }] };
+            }
+            try {
+                const response = await fetch(`${CLAUDETTE_API}/api/workflow/branch?path=${encodeURIComponent(workspacePath)}&fetch=${doFetch}`);
+                const info = await response.json();
+                let output = `Branch Info\n${'='.repeat(50)}\n\n`;
+                output += `Current Branch: ${info.current}\n`;
+                output += `Is Main/Master: ${info.isMain ? 'Yes' : 'No'}\n`;
+                output += `Main Branch: ${info.mainBranch}\n`;
+                output += `Has Remote Tracking: ${info.hasRemote ? 'Yes' : 'No'}\n`;
+                if (!info.isMain) {
+                    output += `\nSync Status:\n`;
+                    output += `────────────────────────────────────────\n`;
+                    if (info.behindMain > 0) {
+                        output += `⚠️ Behind ${info.mainBranch}: ${info.behindMain} commit(s)\n`;
+                        output += `   Run sync_branch to update\n`;
+                    }
+                    else {
+                        output += `✅ Up to date with ${info.mainBranch}\n`;
+                    }
+                }
+                if (info.hasRemote) {
+                    output += `\nRemote Status:\n`;
+                    output += `────────────────────────────────────────\n`;
+                    if (info.behindRemote > 0) {
+                        output += `⚠️ Behind origin: ${info.behindRemote} commit(s) - pull needed\n`;
+                    }
+                    if (info.aheadRemote > 0) {
+                        output += `📤 Ahead of origin: ${info.aheadRemote} commit(s) - push needed\n`;
+                    }
+                    if (info.behindRemote === 0 && info.aheadRemote === 0) {
+                        output += `✅ In sync with origin\n`;
+                    }
+                }
+                if (info.isMain) {
+                    output += `\n⚠️ Best Practice: Create a feature branch instead of committing to ${info.mainBranch}\n`;
+                    output += `   Use create_branch to start a new feature branch\n`;
+                }
+                return { content: [{ type: "text", text: output }] };
+            }
+            catch (err) {
+                return { content: [{ type: "text", text: `Error: ${err.message}` }] };
+            }
+        }
+        case "create_branch": {
+            const workspacePath = args?.workspace_path;
+            const branchName = args?.branch_name;
+            if (!workspacePath) {
+                return { content: [{ type: "text", text: "Error: workspace_path is required" }] };
+            }
+            if (!branchName) {
+                return { content: [{ type: "text", text: "Error: branch_name is required" }] };
+            }
+            try {
+                const response = await fetch(`${CLAUDETTE_API}/api/workflow/branch`, {
+                    method: "POST",
+                    headers: { "Content-Type": "application/json" },
+                    body: JSON.stringify({ path: workspacePath, name: branchName }),
+                });
+                const result = await response.json();
+                if (result.success) {
+                    return { content: [{ type: "text", text: `✅ Created and switched to branch: ${result.branch}\n\nYou can now make changes and commit to this branch.` }] };
+                }
+                else {
+                    return { content: [{ type: "text", text: `❌ Failed to create branch: ${result.error}` }] };
+                }
+            }
+            catch (err) {
+                return { content: [{ type: "text", text: `Error: ${err.message}` }] };
+            }
+        }
+        case "sync_branch": {
+            const workspacePath = args?.workspace_path;
+            const method = args?.method ?? 'rebase';
+            if (!workspacePath) {
+                return { content: [{ type: "text", text: "Error: workspace_path is required" }] };
+            }
+            try {
+                const response = await fetch(`${CLAUDETTE_API}/api/workflow/sync`, {
+                    method: "POST",
+                    headers: { "Content-Type": "application/json" },
+                    body: JSON.stringify({ path: workspacePath, method }),
+                });
+                const result = await response.json();
+                if (result.success) {
+                    return { content: [{ type: "text", text: `✅ Branch synced successfully using ${method}!\n\nYour branch is now up to date with main.` }] };
+                }
+                else {
+                    return { content: [{ type: "text", text: `❌ Sync failed: ${result.error}` }] };
+                }
+            }
+            catch (err) {
+                return { content: [{ type: "text", text: `Error: ${err.message}` }] };
+            }
+        }
         default:
             return { content: [{ type: "text", text: `Unknown tool: ${name}` }] };
     }

package/package.json

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