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

Step 159: add agent marketplace registry

Browse Source
This commit is contained in:
Bill
2026-02-09 19:39:40 -07:00
parent c21c52f55b
commit 3d919d39c5
8 changed files with 331 additions and 1 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
PROGRESS.md
View File

@@ -506,3 +506,4 @@ Sprint 5 in progress. Step 141 (Emacs daemon with user config) done. Next: Step
| 2026-02-10 | Codex | Step 156: Agent annotation assistant RPC with suggestions/diagnostics, feedback learning, and mutation apply helpers. 5/5 tests pass. |
| 2026-02-10 | Codex | Step 157: Multi-agent roles with permission policy, agent provenance in transform history, and UI role controls. 8/8 tests pass. |
| 2026-02-10 | Codex | Step 158: Agent workflow recorder with JSON export, replay support, and RPC wiring. 5/5 tests pass. |
| 2026-02-10 | Codex | Step 159: Agent marketplace registry with UI panel, install toggles, and registry serialization. 6/6 tests pass. |

4
editor/CMakeLists.txt
View File

@@ -890,6 +890,10 @@ add_executable(step158_test tests/step158_test.cpp)
target_include_directories(step158_test PRIVATE src)
target_link_libraries(step158_test PRIVATE nlohmann_json::nlohmann_json)
add_executable(step159_test tests/step159_test.cpp)
target_include_directories(step159_test PRIVATE src)
target_link_libraries(step159_test PRIVATE nlohmann_json::nlohmann_json)
find_package(SDL2 CONFIG REQUIRED)
find_package(OpenGL REQUIRED)
find_package(glad CONFIG REQUIRED)

128
editor/src/AgentMarketplace.h Normal file
View File

@@ -0,0 +1,128 @@
#pragma once
// Step 159: Agent marketplace UI
#include "imgui.h"
#include "AgentRegistry.h"
#include <string>
#include <algorithm>
struct AgentMarketplaceState {
char filterBuf[128] = {};
char registryPathBuf[260] = {};
char registryUrlBuf[260] = {};
std::string selectedAgent;
};
static bool agentMatchesFilter(const AgentDescriptor& agent,
const std::string& filter) {
if (filter.empty()) return true;
std::string name = agent.name;
std::string desc = agent.description;
std::string f = filter;
std::transform(name.begin(), name.end(), name.begin(),
[](unsigned char c) { return (char)std::tolower(c); });
std::transform(desc.begin(), desc.end(), desc.begin(),
[](unsigned char c) { return (char)std::tolower(c); });
std::transform(f.begin(), f.end(), f.begin(),
[](unsigned char c) { return (char)std::tolower(c); });
return name.find(f) != std::string::npos || desc.find(f) != std::string::npos;
}
static void renderAgentMarketplace(AgentMarketplaceState& state,
AgentRegistry& registry,
std::string& outputLog,
const std::string& workspaceRoot) {
if (state.registryPathBuf[0] == '\0') {
std::string path = workspaceRoot.empty() ? "agents.json"
: (workspaceRoot + "\\agents.json");
std::snprintf(state.registryPathBuf, sizeof(state.registryPathBuf), "%s", path.c_str());
}
if (state.registryUrlBuf[0] == '\0' && !registry.getRegistryUrl().empty()) {
std::snprintf(state.registryUrlBuf, sizeof(state.registryUrlBuf), "%s",
registry.getRegistryUrl().c_str());
}
ImGui::InputText("Filter", state.filterBuf, sizeof(state.filterBuf));
ImGui::InputText("Registry URL", state.registryUrlBuf, sizeof(state.registryUrlBuf));
if (ImGui::Button("Set URL")) {
registry.setRegistryUrl(state.registryUrlBuf);
outputLog += "[agents] Registry URL set.\n";
}
ImGui::SameLine();
if (ImGui::Button("Refresh")) {
outputLog += "[agents] STUB: refresh registry from " +
std::string(state.registryUrlBuf) + "\n";
}
ImGui::InputText("Registry File", state.registryPathBuf, sizeof(state.registryPathBuf));
if (ImGui::Button("Load")) {
std::string error;
if (!registry.loadFromFile(state.registryPathBuf, error)) {
outputLog += "[agents] Load failed: " + error + "\n";
} else {
outputLog += "[agents] Loaded registry.\n";
}
}
ImGui::SameLine();
if (ImGui::Button("Save")) {
std::string error;
if (!registry.saveToFile(state.registryPathBuf, error)) {
outputLog += "[agents] Save failed: " + error + "\n";
} else {
outputLog += "[agents] Saved registry.\n";
}
}
ImGui::Separator();
ImGui::TextUnformatted("Available Agents");
std::string filter = state.filterBuf;
const auto& agents = registry.list();
if (agents.empty()) {
ImGui::TextDisabled("(no agents)");
} else {
for (const auto& agent : agents) {
if (!agentMatchesFilter(agent, filter)) continue;
std::string label = agent.name;
if (agent.installed) label += " [installed]";
bool selected = state.selectedAgent == agent.name;
if (ImGui::Selectable(label.c_str(), selected)) {
state.selectedAgent = agent.name;
}
}
}
ImGui::Separator();
if (!state.selectedAgent.empty()) {
AgentDescriptor* selected = registry.find(state.selectedAgent);
if (selected) {
ImGui::Text("Name: %s", selected->name.c_str());
ImGui::TextWrapped("%s", selected->description.c_str());
ImGui::Text("Endpoint: %s", selected->endpoint.c_str());
if (!selected->capabilities.empty()) {
ImGui::Text("Capabilities:");
for (const auto& cap : selected->capabilities) {
ImGui::BulletText("%s", cap.c_str());
}
}
if (!selected->requiredPermissions.empty()) {
ImGui::Text("Permissions:");
for (const auto& perm : selected->requiredPermissions) {
ImGui::BulletText("%s", perm.c_str());
}
}
if (!selected->installed) {
if (ImGui::Button("Install Agent")) {
selected->installed = true;
outputLog += "[agents] Installed " + selected->name +
" (" + selected->endpoint + ")\n";
}
} else {
if (ImGui::Button("Uninstall Agent")) {
selected->installed = false;
outputLog += "[agents] Uninstalled " + selected->name + "\n";
}
}
}
}
}

138
editor/src/AgentRegistry.h Normal file
View File

@@ -0,0 +1,138 @@
#pragma once
// Step 159: Agent registry for marketplace
#include <string>
#include <vector>
#include <fstream>
#include <sstream>
#include <algorithm>
#include <nlohmann/json.hpp>
using json = nlohmann::json;
struct AgentDescriptor {
std::string name;
std::string description;
std::string endpoint;
std::vector<std::string> capabilities;
std::vector<std::string> requiredPermissions;
bool installed = false;
};
class AgentRegistry {
public:
const std::vector<AgentDescriptor>& list() const { return agents_; }
AgentDescriptor* find(const std::string& name) {
for (auto& a : agents_) {
if (a.name == name) return &a;
}
return nullptr;
}
void upsert(const AgentDescriptor& agent) {
if (auto* existing = find(agent.name)) {
*existing = agent;
} else {
agents_.push_back(agent);
}
}
void remove(const std::string& name) {
agents_.erase(std::remove_if(agents_.begin(), agents_.end(),
[&](const AgentDescriptor& a) {
return a.name == name;
}),
agents_.end());
}
void clear() { agents_.clear(); }
void setRegistryUrl(const std::string& url) { registryUrl_ = url; }
const std::string& getRegistryUrl() const { return registryUrl_; }
bool loadFromFile(const std::string& path, std::string& error) {
std::ifstream in(path);
if (!in.is_open()) {
error = "Could not open file: " + path;
return false;
}
std::ostringstream ss;
ss << in.rdbuf();
return loadFromJsonString(ss.str(), error);
}
bool saveToFile(const std::string& path, std::string& error) const {
std::ofstream out(path);
if (!out.is_open()) {
error = "Could not write file: " + path;
return false;
}
out << toJson().dump(2);
return true;
}
bool loadFromJsonString(const std::string& text, std::string& error) {
try {
json j = json::parse(text);
return loadFromJson(j, error);
} catch (const std::exception& e) {
error = std::string("JSON parse error: ") + e.what();
return false;
}
}
bool loadFromJson(const json& j, std::string& error) {
if (!j.is_object()) {
error = "Invalid registry format";
return false;
}
registryUrl_ = j.value("registryUrl", registryUrl_);
if (!j.contains("agents") || !j["agents"].is_array()) {
error = "Missing agents list";
return false;
}
agents_.clear();
for (const auto& item : j["agents"]) {
AgentDescriptor desc;
desc.name = item.value("name", "");
desc.description = item.value("description", "");
desc.endpoint = item.value("endpoint", "");
desc.installed = item.value("installed", false);
if (item.contains("capabilities")) {
for (const auto& cap : item["capabilities"]) {
desc.capabilities.push_back(cap.get<std::string>());
}
}
if (item.contains("requiredPermissions")) {
for (const auto& perm : item["requiredPermissions"]) {
desc.requiredPermissions.push_back(perm.get<std::string>());
}
}
if (!desc.name.empty()) agents_.push_back(std::move(desc));
}
return true;
}
json toJson() const {
json out;
out["registryUrl"] = registryUrl_;
json arr = json::array();
for (const auto& agent : agents_) {
arr.push_back({
{"name", agent.name},
{"description", agent.description},
{"endpoint", agent.endpoint},
{"capabilities", agent.capabilities},
{"requiredPermissions", agent.requiredPermissions},
{"installed", agent.installed}
});
}
out["agents"] = arr;
return out;
}
private:
std::string registryUrl_;
std::vector<AgentDescriptor> agents_;
};

4
editor/src/EditorState.h
View File

@@ -43,6 +43,8 @@
#include "TerminalPanel.h"
#include "WebSocketServer.h"
#include "WorkflowRecorder.h"
#include "AgentRegistry.h"
#include "AgentMarketplace.h"
#include "BuildSystem.h"
#include "DependencyPanel.h"
#include "LibraryIndexer.h"
@@ -178,6 +180,8 @@ struct EditorState {
std::vector<std::string> agentLog;
std::map<std::string, AgentRole> agentRoles;
WorkflowRecorder workflowRecorder;
AgentRegistry agentRegistry;
AgentMarketplaceState agentMarketplace;
BuildSystem::Type buildType = BuildSystem::Type::None;
std::vector<BuildError> buildErrors;
std::string lastBuildOutput;

10
editor/src/main.cpp
View File

@@ -1939,6 +1939,16 @@ int main(int, char**) {
ImGui::EndTabItem();
}
if (ImGui::BeginTabItem("Marketplace")) {
ImGui::PushFont(monoFont);
renderAgentMarketplace(state.agentMarketplace,
state.agentRegistry,
state.outputLog,
state.workspaceRoot);
ImGui::PopFont();
ImGui::EndTabItem();
}
if (ImGui::BeginTabItem("Build")) {
ImGui::PushFont(uiFont);
ImGui::Text("Detected: %s", BuildSystem::typeName(state.buildType));

45
editor/tests/step159_test.cpp Normal file
View File

@@ -0,0 +1,45 @@
// Step 159 TDD Test: Agent registry
#include "AgentRegistry.h"
#include <iostream>
static void expect(bool cond, const std::string& name, int& passed, int& failed) {
if (cond) {
std::cout << "Test " << (passed + failed + 1) << " PASS: " << name << "\n";
++passed;
} else {
std::cout << "Test " << (passed + failed + 1) << " FAIL: " << name << "\n";
++failed;
}
}
int main() {
int passed = 0;
int failed = 0;
AgentRegistry reg;
AgentDescriptor agent;
agent.name = "TestAgent";
agent.description = "Example agent";
agent.endpoint = "ws://localhost:9001";
agent.capabilities = {"lint", "refactor"};
agent.requiredPermissions = {"getAST", "applyMutation"};
agent.installed = true;
reg.upsert(agent);
expect(reg.find("TestAgent") != nullptr, "agent inserted", passed, failed);
expect(reg.list().size() == 1, "registry size", passed, failed);
json j = reg.toJson();
AgentRegistry reg2;
std::string error;
expect(reg2.loadFromJson(j, error), "load from json", passed, failed);
expect(reg2.list().size() == 1, "loaded size", passed, failed);
expect(reg2.list()[0].installed, "installed flag preserved", passed, failed);
AgentRegistry reg3;
expect(!reg3.loadFromJsonString("not json", error), "invalid json rejected", passed, failed);
std::cout << "\n=== Step 159 Results: " << passed << " passed, "
<< failed << " failed ===\n";
return failed == 0 ? 0 : 1;
}

2
sprint5_plan.md
View File

@@ -328,7 +328,7 @@ primitives, and assist with constructive coding.
workflows on different codebases. Workflows are shareable.
*New:* `WorkflowRecorder.h`
- [ ] **Step 159: Agent marketplace / plugin registry**
- [x] **Step 159: Agent marketplace / plugin registry**
Directory of available Whetstone agents (local + remote). Each agent
has: name, description, capabilities, required permissions.
"Install Agent" connects to the agent's WebSocket endpoint.