Add step 619 per-project MCP config

editor/src/MCPProjectConfig.h

@@ -0,0 +1,102 @@
+#pragma once
+// Step 619: Per-project MCP config (.whetstone.json)
+
+#include <filesystem>
+#include <fstream>
+#include <string>
+
+#include <nlohmann/json.hpp>
+
+using json = nlohmann::json;
+
+struct MCPProjectConfigData {
+    std::string workspace;
+    std::string defaultLanguage;
+    std::string agentRole;
+    std::string mcpWorkspaceAlias;
+};
+
+struct MCPProjectConfigLoadResult {
+    bool found = false;
+    MCPProjectConfigData config;
+    std::string error;
+};
+
+class MCPProjectConfig {
+public:
+    static bool parseText(const std::string& text,
+                          MCPProjectConfigData* out,
+                          std::string* error) {
+        if (!out || !error) return false;
+        error->clear();
+        if (text.empty()) {
+            *error = "config_empty";
+            return false;
+        }
+
+        json parsed;
+        try {
+            parsed = json::parse(text);
+        } catch (...) {
+            *error = "config_json_parse_failed";
+            return false;
+        }
+        return parseJson(parsed, out, error);
+    }
+
+    static bool parseJson(const json& parsed,
+                          MCPProjectConfigData* out,
+                          std::string* error) {
+        if (!out || !error) return false;
+        error->clear();
+        if (!parsed.is_object()) {
+            *error = "config_not_object";
+            return false;
+        }
+
+        MCPProjectConfigData data;
+        if (!readOptionalString(parsed, "workspace", &data.workspace, error)) return false;
+        if (!readOptionalString(parsed, "defaultLanguage", &data.defaultLanguage, error)) return false;
+        if (!readOptionalString(parsed, "agentRole", &data.agentRole, error)) return false;
+        if (!readOptionalString(parsed, "mcpWorkspaceAlias", &data.mcpWorkspaceAlias, error)) return false;
+        *out = data;
+        return true;
+    }
+
+    static MCPProjectConfigLoadResult loadFromWorkspace(const std::string& workspaceRoot) {
+        MCPProjectConfigLoadResult out;
+        if (workspaceRoot.empty()) {
+            out.error = "workspace_missing";
+            return out;
+        }
+
+        std::filesystem::path path = std::filesystem::path(workspaceRoot) / ".whetstone.json";
+        if (!std::filesystem::exists(path)) return out;
+        out.found = true;
+
+        std::ifstream in(path);
+        if (!in.is_open()) {
+            out.error = "config_open_failed";
+            return out;
+        }
+
+        std::string text((std::istreambuf_iterator<char>(in)),
+                         std::istreambuf_iterator<char>());
+        if (!parseText(text, &out.config, &out.error)) return out;
+        return out;
+    }
+
+private:
+    static bool readOptionalString(const json& parsed,
+                                   const char* key,
+                                   std::string* out,
+                                   std::string* error) {
+        if (!parsed.contains(key)) return true;
+        if (!parsed[key].is_string()) {
+            *error = std::string("config_field_invalid_type:") + key;
+            return false;
+        }
+        *out = parsed[key].get<std::string>();
+        return true;
+    }
+};

editor/src/mcp_main.cpp

@@ -8,6 +8,8 @@
 
 #include "HeadlessEditorState.h"
 #include "MCPBridge.h"
+#include "MCPProjectConfig.h"
+#include "AgentPermissionPolicy.h"
 #include "ast/Serialization.h"
 
 #include <csignal>
@@ -116,14 +118,34 @@ int main(int argc, char** argv) {
     // Create headless state
     HeadlessEditorState state;
     state.verbose = verbose;
-    if (!workspace.empty()) state.workspaceRoot = workspace;
-    if (!language.empty())  state.defaultLanguage = language;
+    MCPProjectConfigLoadResult configLoad;
+    if (!workspace.empty()) {
+        configLoad = MCPProjectConfig::loadFromWorkspace(workspace);
+        if (!configLoad.error.empty()) {
+            std::cerr << "[whetstone-mcp] Config load warning: " << configLoad.error << "\n";
+        }
+    }
+
+    if (configLoad.found && !configLoad.config.workspace.empty()) {
+        state.workspaceRoot = configLoad.config.workspace;
+    } else if (!workspace.empty()) {
+        state.workspaceRoot = workspace;
+    }
+
+    if (!language.empty()) {
+        state.defaultLanguage = language;
+    } else if (configLoad.found && !configLoad.config.defaultLanguage.empty()) {
+        state.defaultLanguage = configLoad.config.defaultLanguage;
+    }
 
     // Create an empty default buffer so getAST etc. work immediately
     state.openBuffer("(scratch)", "", state.defaultLanguage);
 
-    // Set default agent role to Refactor for full MCP access
-    state.setAgentRole("mcp-session", AgentRole::Refactor);
+    AgentRole role = AgentRole::Refactor;
+    if (configLoad.found && !configLoad.config.agentRole.empty()) {
+        role = AgentPermissionPolicy::roleFromString(configLoad.config.agentRole);
+    }
+    state.setAgentRole("mcp-session", role);
 
     // Create bridge and wire handlers
     MCPBridge bridge;
@@ -138,8 +160,11 @@ int main(int argc, char** argv) {
 
     // Log startup info to stderr (stdout is the MCP transport)
     std::cerr << "[whetstone-mcp] Starting MCP server v0.1.0\n";
-    if (!workspace.empty())
-        std::cerr << "[whetstone-mcp] Workspace: " << workspace << "\n";
+    if (!state.workspaceRoot.empty())
+        std::cerr << "[whetstone-mcp] Workspace: " << state.workspaceRoot << "\n";
+    if (configLoad.found && !configLoad.config.mcpWorkspaceAlias.empty())
+        std::cerr << "[whetstone-mcp] Workspace alias: "
+                  << configLoad.config.mcpWorkspaceAlias << "\n";
     std::cerr << "[whetstone-mcp] Language: " << state.defaultLanguage << "\n";
     if (verbose)
         std::cerr << "[whetstone-mcp] Verbose mode enabled\n";