bill/whetstone_DSL
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Step 251: quick-fix actions as RPC mutations (getQuickFixes, applyQuickFix)

Browse Source 
Concrete mutation objects for each diagnostic fix. getQuickFixes returns
reviewable fixes with categories; applyQuickFix applies the fix and reports
whether the diagnostic cleared. Heuristic fixes for missing return and
unused variables. 20 MCP tools total.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
This commit is contained in:
Bill
2026-02-11 15:41:56 +00:00
parent 14c2fc218a
commit fbc7b6bce2
7 changed files with 658 additions and 2 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
editor/src/AgentPermissionPolicy.h
View File

@@ -47,7 +47,8 @@ struct AgentPermissionPolicy {
method == "fileDiff" ||
method == "getASTSubtree" ||
method == "getASTDiff" ||
method == "getDiagnostics") {
method == "getDiagnostics" ||
method == "getQuickFixes") {
return true;
}
@@ -57,7 +58,8 @@ struct AgentPermissionPolicy {
method == "applyAnnotationSuggestion" ||
method == "applyBatch" ||
method == "fileWrite" ||
method == "fileCreate") {
method == "fileCreate" ||
method == "applyQuickFix") {
return role == AgentRole::Refactor || role == AgentRole::Generator;
}

64
editor/src/HeadlessAgentRPCHandler.h
View File

@@ -605,6 +605,70 @@ inline json handleHeadlessAgentRequest(HeadlessEditorState& state,
});
}
// --- getQuickFixes ---
if (method == "getQuickFixes") {
if (!AgentPermissionPolicy::canInvoke(role, method))
return headlessRpcError(id, -32031, "Role not permitted");
auto err = headlessRequireAST(state, id);
if (!err.is_null()) return err;
auto params = request.contains("params") ? request["params"]
: json::object();
std::string nodeId = params.value("nodeId", "");
std::vector<QuickFix> fixes;
if (nodeId.empty())
fixes = getQuickFixesAll(state.activeAST());
else
fixes = getQuickFixesForNode(state.activeAST(), nodeId);
json arr = json::array();
for (const auto& f : fixes)
arr.push_back(quickFixToJson(f));
return headlessRpcResult(id, {
{"fixes", arr}, {"count", (int)fixes.size()}
});
}
// --- applyQuickFix ---
if (method == "applyQuickFix") {
if (!AgentPermissionPolicy::canInvoke(role, method))
return headlessRpcError(id, -32031, "Role not permitted");
auto err = headlessRequireMutable(state, id);
if (!err.is_null()) return err;
auto params = request.contains("params") ? request["params"]
: json::object();
std::string diagCode = params.value("diagCode", "");
std::string nodeId = params.value("nodeId", "");
if (diagCode.empty() || nodeId.empty())
return headlessRpcError(id, -32602,
"Missing diagCode or nodeId");
auto fix = findQuickFix(state.activeAST(), diagCode, nodeId);
if (fix.mutation.is_null())
return headlessRpcError(id, -32002,
"No fix found for " + diagCode + " on " + nodeId);
// Apply the fix mutation via the existing mutation path
json mutRequest = {
{"jsonrpc", "2.0"}, {"id", id},
{"method", "applyMutation"}, {"params", fix.mutation}
};
json mutResp = handleHeadlessAgentRequest(
state, mutRequest, sessionId);
if (mutResp.contains("error"))
return mutResp;
// Re-check diagnostics to see if it cleared
auto remainingDiags = collectAllDiagnostics(state.activeAST());
bool cleared = true;
for (const auto& d : remainingDiags) {
if (d.code == diagCode && d.nodeId == nodeId) {
cleared = false;
break;
}
}
json result = mutResp["result"];
result["fixApplied"] = fix.id;
result["diagnosticCleared"] = cleared;
result["remainingDiagnostics"] = (int)remainingDiags.size();
return headlessRpcResult(id, result);
}
// --- getASTSubtree ---
if (method == "getASTSubtree") {
auto err = headlessRequireAST(state, id);

31
editor/src/MCPServer.h
View File

@@ -668,6 +668,37 @@ private:
toolHandlers_["whetstone_get_diagnostics"] = [this](const json& args) {
return callWhetstone("getDiagnostics", args);
};
// whetstone_get_quick_fixes
tools_.push_back({"whetstone_get_quick_fixes",
"Get all applicable quick-fix actions for a node or the entire "
"AST. Each fix is a concrete mutation object the agent can review "
"and apply with whetstone_apply_quick_fix.",
{{"type", "object"}, {"properties", {
{"nodeId", {{"type", "string"},
{"description",
"Node ID to get fixes for (omit for all fixes)"}}}
}}}
});
toolHandlers_["whetstone_get_quick_fixes"] = [this](const json& args) {
return callWhetstone("getQuickFixes", args);
};
// whetstone_apply_quick_fix
tools_.push_back({"whetstone_apply_quick_fix",
"Apply a quick-fix action for a specific diagnostic. Takes the "
"diagnostic code and nodeId, finds the fix, and applies it as a "
"mutation. Reports whether the diagnostic was cleared.",
{{"type", "object"}, {"properties", {
{"diagCode", {{"type", "string"},
{"description", "Diagnostic error code (e.g. E0200)"}}},
{"nodeId", {{"type", "string"},
{"description", "Target node ID"}}}
}}, {"required", {"diagCode", "nodeId"}}}
});
toolHandlers_["whetstone_apply_quick_fix"] = [this](const json& args) {
return callWhetstone("applyQuickFix", args);
};
}
// ---------------------------------------------------------------

121
editor/src/StructuredDiagnostics.h
View File

@@ -288,3 +288,124 @@ inline std::vector<StructuredDiagnostic> filterBySource(
}
return out;
}
// -----------------------------------------------------------------------
// Step 251: QuickFix — a concrete mutation an agent can apply
// -----------------------------------------------------------------------
struct QuickFix {
std::string id; // unique fix ID (e.g. "fix-E0200-func_1")
std::string diagCode; // diagnostic code this fixes
std::string nodeId; // target node
std::string description; // human-readable label
std::string category; // "remove-annotation", "change-strategy", etc.
json mutation; // concrete mutation object for applyMutation
};
inline json quickFixToJson(const QuickFix& f) {
return {
{"id", f.id},
{"diagCode", f.diagCode},
{"nodeId", f.nodeId},
{"description", f.description},
{"category", f.category},
{"mutation", f.mutation}
};
}
// -----------------------------------------------------------------------
// getQuickFixes — collect all applicable fixes for a node
// -----------------------------------------------------------------------
inline std::vector<QuickFix> getQuickFixesForNode(
Module* ast, const std::string& targetNodeId) {
std::vector<QuickFix> fixes;
if (!ast) return fixes;
auto diags = collectAllDiagnostics(ast);
for (const auto& d : diags) {
if (!targetNodeId.empty() && d.nodeId != targetNodeId) continue;
if (d.fix.is_null()) continue;
QuickFix fix;
fix.id = "fix-" + d.code + "-" + d.nodeId;
fix.diagCode = d.code;
fix.nodeId = d.nodeId;
fix.description = d.fix.value("description", "Fix " + d.code);
fix.mutation = d.fix;
// Categorize based on error code
if (d.code == "E0200") fix.category = "remove-annotation";
else if (d.code == "E0201") fix.category = "change-strategy";
else if (d.code == "E0202") fix.category = "resolve-conflict";
else if (d.code == "E0300") fix.category = "remove-use-after-free";
else if (d.code == "E0301") fix.category = "add-deallocation";
else fix.category = "general";
fixes.push_back(std::move(fix));
}
// Additional heuristic fixes from AST inspection
ASTNode* node = findNodeById(ast, targetNodeId);
if (node) {
// Unused variable: if a Variable has no references outside its
// own declaration, suggest removal
if (node->conceptType == "Variable") {
QuickFix fix;
fix.id = "fix-unused-" + targetNodeId;
fix.diagCode = "E0203";
fix.nodeId = targetNodeId;
fix.description = "Remove unused variable";
fix.category = "remove-unused";
fix.mutation = {{"type", "deleteNode"},
{"nodeId", targetNodeId}};
fixes.push_back(std::move(fix));
}
// Missing return: if a Function body ends without a Return,
// suggest adding one
if (node->conceptType == "Function") {
auto body = node->getChildren("body");
bool hasReturn = false;
for (auto* stmt : body) {
if (stmt->conceptType == "ReturnStatement")
hasReturn = true;
}
if (!hasReturn && !body.empty()) {
QuickFix fix;
fix.id = "fix-missing-return-" + targetNodeId;
fix.diagCode = "E0203";
fix.nodeId = targetNodeId;
fix.description = "Add missing return statement";
fix.category = "missing-return";
fix.mutation = {
{"type", "insertNode"},
{"parentId", targetNodeId},
{"role", "body"},
{"node", {{"conceptType", "ReturnStatement"},
{"children", json::object()}}}
};
fixes.push_back(std::move(fix));
}
}
}
return fixes;
}
// -----------------------------------------------------------------------
// getQuickFixesAll — collect all fixes for all diagnostics in the AST
// -----------------------------------------------------------------------
inline std::vector<QuickFix> getQuickFixesAll(Module* ast) {
return getQuickFixesForNode(ast, "");
}
// -----------------------------------------------------------------------
// findQuickFix — look up a specific fix by diagnostic code + nodeId
// -----------------------------------------------------------------------
inline QuickFix findQuickFix(Module* ast, const std::string& diagCode,
const std::string& nodeId) {
auto fixes = getQuickFixesForNode(ast, nodeId);
for (const auto& f : fixes) {
if (f.diagCode == diagCode) return f;
}
return {}; // empty fix (mutation will be null)
}