diff --git a/editor/CMakeLists.txt b/editor/CMakeLists.txt index 4df3bd9..1557759 100644 --- a/editor/CMakeLists.txt +++ b/editor/CMakeLists.txt @@ -4153,4 +4153,13 @@ target_link_libraries(step585_test PRIVATE tree_sitter_javascript tree_sitter_typescript tree_sitter_java tree_sitter_rust tree_sitter_go) +add_executable(step586_test tests/step586_test.cpp) +target_include_directories(step586_test PRIVATE src) +target_link_libraries(step586_test PRIVATE + nlohmann_json::nlohmann_json + unofficial::tree-sitter::tree-sitter + tree_sitter_python tree_sitter_cpp tree_sitter_elisp + tree_sitter_javascript tree_sitter_typescript + tree_sitter_java tree_sitter_rust tree_sitter_go) + # Step 12: Dear ImGui shell scaffolding created (main.cpp exists but not built due to dependencies) diff --git a/editor/src/CapabilityDiscoveryPanels.h b/editor/src/CapabilityDiscoveryPanels.h new file mode 100644 index 0000000..694ad91 --- /dev/null +++ b/editor/src/CapabilityDiscoveryPanels.h @@ -0,0 +1,86 @@ +#pragma once +// Step 586: Capability Discovery Panels + +#include +#include +#include +#include + +struct CapabilityCategory { + std::string categoryId; + std::string title; + int operationCount = 0; + std::vector recommendations; +}; + +class CapabilityDiscoveryPanels { +public: + bool registerCategory(const std::string& categoryId, + const std::string& title, + std::string* error) { + if (!error) return false; + error->clear(); + if (categoryId.empty()) return fail(error, "category_id_missing"); + if (title.empty()) return fail(error, "category_title_missing"); + if (categories_.count(categoryId) != 0) return fail(error, "category_duplicate"); + CapabilityCategory c; + c.categoryId = categoryId; + c.title = title; + categories_[categoryId] = c; + return true; + } + + bool recordOperation(const std::string& categoryId, std::string* error) { + if (!error) return false; + error->clear(); + auto it = categories_.find(categoryId); + if (it == categories_.end()) return fail(error, "category_missing"); + ++it->second.operationCount; + return true; + } + + bool addRecommendation(const std::string& categoryId, + const std::string& recommendation, + std::string* error) { + if (!error) return false; + error->clear(); + auto it = categories_.find(categoryId); + if (it == categories_.end()) return fail(error, "category_missing"); + if (recommendation.empty()) return fail(error, "recommendation_missing"); + for (const auto& r : it->second.recommendations) { + if (r == recommendation) return fail(error, "recommendation_duplicate"); + } + it->second.recommendations.push_back(recommendation); + return true; + } + + std::vector sortedByOperationCountDesc() const { + std::vector out; + for (const auto& kv : categories_) out.push_back(kv.second); + std::stable_sort(out.begin(), out.end(), [](const CapabilityCategory& a, const CapabilityCategory& b) { + if (a.operationCount != b.operationCount) return a.operationCount > b.operationCount; + return a.categoryId < b.categoryId; + }); + return out; + } + + std::vector recommendationsFor(const std::string& categoryId) const { + auto it = categories_.find(categoryId); + if (it == categories_.end()) return {}; + return it->second.recommendations; + } + + int operationCountFor(const std::string& categoryId) const { + auto it = categories_.find(categoryId); + if (it == categories_.end()) return 0; + return it->second.operationCount; + } + +private: + std::map categories_; + + static bool fail(std::string* error, const char* code) { + *error = code; + return false; + } +}; diff --git a/editor/tests/step586_test.cpp b/editor/tests/step586_test.cpp new file mode 100644 index 0000000..b890f78 --- /dev/null +++ b/editor/tests/step586_test.cpp @@ -0,0 +1,150 @@ +// Step 586: Capability Discovery Panels (12 tests) + +#include "CapabilityDiscoveryPanels.h" + +#include + +static int passed = 0, failed = 0; +#define TEST(name) { std::cout << " " << #name << "... "; } +#define PASS() { std::cout << "PASS\n"; ++passed; } +#define FAIL(msg) { std::cout << "FAIL: " << msg << "\n"; ++failed; } +#define CHECK(cond, msg) if (!(cond)) { FAIL(msg); return; } else {} + +void test_register_category_success() { + TEST(register_category_success); + CapabilityDiscoveryPanels p; + std::string error; + CHECK(p.registerCategory("mcp", "MCP Tools", &error), "register should succeed"); + CHECK(p.operationCountFor("mcp") == 0, "initial count should be zero"); + PASS(); +} + +void test_register_category_rejects_missing_id() { + TEST(register_category_rejects_missing_id); + CapabilityDiscoveryPanels p; + std::string error; + CHECK(!p.registerCategory("", "MCP Tools", &error), "register should fail"); + CHECK(error == "category_id_missing", "wrong error"); + PASS(); +} + +void test_register_category_rejects_duplicate() { + TEST(register_category_rejects_duplicate); + CapabilityDiscoveryPanels p; + std::string error; + CHECK(p.registerCategory("mcp", "MCP Tools", &error), "first register failed"); + CHECK(!p.registerCategory("mcp", "Dup", &error), "duplicate should fail"); + CHECK(error == "category_duplicate", "wrong error"); + PASS(); +} + +void test_record_operation_increments_count() { + TEST(record_operation_increments_count); + CapabilityDiscoveryPanels p; + std::string error; + CHECK(p.registerCategory("mcp", "MCP Tools", &error), "register failed"); + CHECK(p.recordOperation("mcp", &error), "record failed"); + CHECK(p.recordOperation("mcp", &error), "record failed"); + CHECK(p.operationCountFor("mcp") == 2, "count mismatch"); + PASS(); +} + +void test_record_operation_fails_for_unknown_category() { + TEST(record_operation_fails_for_unknown_category); + CapabilityDiscoveryPanels p; + std::string error; + CHECK(!p.recordOperation("missing", &error), "record should fail"); + CHECK(error == "category_missing", "wrong error"); + PASS(); +} + +void test_add_recommendation_success() { + TEST(add_recommendation_success); + CapabilityDiscoveryPanels p; + std::string error; + CHECK(p.registerCategory("mcp", "MCP Tools", &error), "register failed"); + CHECK(p.addRecommendation("mcp", "Try tree-sitter panel", &error), "recommendation add failed"); + CHECK(p.recommendationsFor("mcp").size() == 1, "recommendation count mismatch"); + PASS(); +} + +void test_add_recommendation_rejects_duplicate() { + TEST(add_recommendation_rejects_duplicate); + CapabilityDiscoveryPanels p; + std::string error; + CHECK(p.registerCategory("mcp", "MCP Tools", &error), "register failed"); + CHECK(p.addRecommendation("mcp", "Try tree-sitter panel", &error), "add failed"); + CHECK(!p.addRecommendation("mcp", "Try tree-sitter panel", &error), "duplicate should fail"); + CHECK(error == "recommendation_duplicate", "wrong error"); + PASS(); +} + +void test_add_recommendation_rejects_missing_text() { + TEST(add_recommendation_rejects_missing_text); + CapabilityDiscoveryPanels p; + std::string error; + CHECK(p.registerCategory("mcp", "MCP Tools", &error), "register failed"); + CHECK(!p.addRecommendation("mcp", "", &error), "add should fail"); + CHECK(error == "recommendation_missing", "wrong error"); + PASS(); +} + +void test_sorted_by_operation_count_desc() { + TEST(sorted_by_operation_count_desc); + CapabilityDiscoveryPanels p; + std::string error; + CHECK(p.registerCategory("mcp", "MCP Tools", &error), "register mcp failed"); + CHECK(p.registerCategory("verify", "Verification", &error), "register verify failed"); + CHECK(p.recordOperation("verify", &error), "record verify failed"); + CHECK(p.recordOperation("verify", &error), "record verify failed"); + CHECK(p.recordOperation("mcp", &error), "record mcp failed"); + const auto sorted = p.sortedByOperationCountDesc(); + CHECK(sorted[0].categoryId == "verify", "verify should rank first"); + CHECK(sorted[1].categoryId == "mcp", "mcp should rank second"); + PASS(); +} + +void test_sorted_tie_breaks_by_category_id() { + TEST(sorted_tie_breaks_by_category_id); + CapabilityDiscoveryPanels p; + std::string error; + CHECK(p.registerCategory("a", "A", &error), "register a failed"); + CHECK(p.registerCategory("b", "B", &error), "register b failed"); + const auto sorted = p.sortedByOperationCountDesc(); + CHECK(sorted[0].categoryId == "a", "a should come first on tie"); + PASS(); +} + +void test_recommendations_for_unknown_category_empty() { + TEST(recommendations_for_unknown_category_empty); + CapabilityDiscoveryPanels p; + CHECK(p.recommendationsFor("missing").empty(), "unknown category should return empty recommendations"); + PASS(); +} + +void test_operation_count_for_unknown_category_zero() { + TEST(operation_count_for_unknown_category_zero); + CapabilityDiscoveryPanels p; + CHECK(p.operationCountFor("missing") == 0, "unknown category count should be zero"); + PASS(); +} + +int main() { + std::cout << "Step 586: Capability Discovery Panels\n"; + + test_register_category_success(); // 1 + test_register_category_rejects_missing_id(); // 2 + test_register_category_rejects_duplicate(); // 3 + test_record_operation_increments_count(); // 4 + test_record_operation_fails_for_unknown_category();// 5 + test_add_recommendation_success(); // 6 + test_add_recommendation_rejects_duplicate(); // 7 + test_add_recommendation_rejects_missing_text(); // 8 + test_sorted_by_operation_count_desc(); // 9 + test_sorted_tie_breaks_by_category_id(); // 10 + test_recommendations_for_unknown_category_empty();// 11 + test_operation_count_for_unknown_category_zero(); // 12 + + std::cout << "\nResults: " << passed << "/" << (passed + failed) << " passed\n"; + return failed == 0 ? 0 : 1; +} diff --git a/progress.md b/progress.md index f6bc9b7..7499aa7 100644 --- a/progress.md +++ b/progress.md @@ -11020,3 +11020,37 @@ plain-language routing/review explanations, with electric-blue visual defaults. - `editor/src/WorkflowVisualizationV2.h` within header-size limit (`118` <= `600`) - `editor/tests/step585_test.cpp` within test-file size guidance (`177` lines) - Header-only architecture and naming conventions remain aligned with `ARCHITECTURE.md` + +### Step 586: Capability Discovery Panels +**Status:** PASS (12/12 tests) + +Implements capability discovery panel state for surfacing tool categories, +operation counts, and contextual recommendations. + +**Files added:** +- `editor/src/CapabilityDiscoveryPanels.h` - capability panel module: + - category registration with validation/duplicate guards + - operation count tracking per category + - recommendation registration with dedupe guards + - category ranking by operation activity + - category-level recommendation/count query helpers +- `editor/tests/step586_test.cpp` - 12 tests covering: + - registration success/failure behavior + - operation count tracking behavior + - recommendation add/dedupe behavior + - ranked sorting behavior + - unknown-category query fallback behavior + +**Files modified:** +- `editor/CMakeLists.txt` - `step586_test` target + +**Verification run:** +- `cmake -S editor -B editor/build-native` - PASS +- `cmake --build editor/build-native --target step586_test step585_test` - PASS +- `./editor/build-native/step586_test` - PASS (12/12) +- `./editor/build-native/step585_test` - PASS (12/12) regression coverage + +**Architecture gate check:** +- `editor/src/CapabilityDiscoveryPanels.h` within header-size limit (`86` <= `600`) +- `editor/tests/step586_test.cpp` within test-file size guidance (`150` lines) +- Header-only architecture and naming conventions remain aligned with `ARCHITECTURE.md`