From e9e54974c649cf2d70c8824d327e88c2a4dfe163 Mon Sep 17 00:00:00 2001 From: Bill Date: Mon, 16 Feb 2026 20:57:29 -0700 Subject: [PATCH] Complete step476 phase23a integration and summary --- editor/CMakeLists.txt | 9 +++ editor/tests/step476_test.cpp | 148 ++++++++++++++++++++++++++++++++++ progress.md | 43 ++++++++++ 3 files changed, 200 insertions(+) create mode 100644 editor/tests/step476_test.cpp diff --git a/editor/CMakeLists.txt b/editor/CMakeLists.txt index 1305ef8..4d2851d 100644 --- a/editor/CMakeLists.txt +++ b/editor/CMakeLists.txt @@ -3163,4 +3163,13 @@ target_link_libraries(step475_test PRIVATE tree_sitter_javascript tree_sitter_typescript tree_sitter_java tree_sitter_rust tree_sitter_go) +add_executable(step476_test tests/step476_test.cpp) +target_include_directories(step476_test PRIVATE src) +target_link_libraries(step476_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/tests/step476_test.cpp b/editor/tests/step476_test.cpp new file mode 100644 index 0000000..088dc35 --- /dev/null +++ b/editor/tests/step476_test.cpp @@ -0,0 +1,148 @@ +// Step 476: Phase 23a Integration Tests (8 tests) + +#include "ArchitectReviewInterface.h" + +#include +#include + +struct WorkflowTask { + std::string moduleName; + std::string functionName; +}; + +static std::vector createWorkflow(const SkeletonProjectSpec& sk) { + std::vector tasks; + for (const auto& m : sk.modules) { + for (const auto& f : m.functions) { + tasks.push_back({m.moduleName, f.name}); + } + } + return tasks; +} + +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 {} + +static ArchitectReviewState runFlow(const std::string& prompt) { + auto req = ArchitectProblemParser::parse(prompt); + auto graph = ArchitectModuleDecomposer::decompose(req, DecompositionStrategy::Layered); + auto stack = ArchitectTechStackSelector::select(req, graph); + auto sk = ArchitectSkeletonGenerator::generate(req, graph, stack); + return ArchitectReviewInterface::initialize(sk, stack, graph); +} + +void test_full_flow_extracts_structured_requirements() { + TEST(full_flow_extracts_structured_requirements); + auto req = ArchitectProblemParser::parse( + "Build a REST API for a bookstore with user auth, PostgreSQL, and a React web frontend."); + CHECK(!req.functionalRequirements.empty(), "missing functional requirements"); + CHECK(!req.integrationRequirements.empty(), "missing integration requirements"); + CHECK(!req.platformConstraints.empty(), "missing platform requirements"); + PASS(); +} + +void test_full_flow_decomposes_expected_modules() { + TEST(full_flow_decomposes_expected_modules); + auto req = ArchitectProblemParser::parse( + "Build a REST API for a bookstore with user auth, PostgreSQL, and a React web frontend."); + auto g = ArchitectModuleDecomposer::decompose(req, DecompositionStrategy::Layered); + CHECK(g.hasModule("api"), "missing api module"); + CHECK(g.hasModule("auth"), "missing auth module"); + CHECK(g.hasModule("data"), "missing data module"); + CHECK(g.hasModule("ui"), "missing ui module"); + PASS(); +} + +void test_full_flow_stack_selects_frontend_and_database() { + TEST(full_flow_stack_selects_frontend_and_database); + auto req = ArchitectProblemParser::parse( + "Build a REST API for a bookstore with user auth, PostgreSQL, and a React web frontend."); + auto g = ArchitectModuleDecomposer::decompose(req, DecompositionStrategy::Layered); + auto stack = ArchitectTechStackSelector::select(req, g); + auto ui = stack.getChoice("ui"); + auto data = stack.getChoice("data"); + CHECK(ui.language == "typescript", "expected typescript frontend"); + CHECK(ui.framework == "react", "expected react framework"); + CHECK(data.database == "postgresql", "expected postgresql"); + PASS(); +} + +void test_full_flow_generates_skeleton_modules_and_annotations() { + TEST(full_flow_generates_skeleton_modules_and_annotations); + auto st = runFlow( + "Build a REST API for a bookstore with user auth, PostgreSQL, and a React web frontend."); + CHECK(st.skeleton.hasModule("api"), "missing api skeleton module"); + auto api = st.skeleton.getModule("api"); + CHECK(!api.functions.empty(), "missing api functions"); + bool hasIntent = false, hasContract = false; + for (const auto& a : api.functions[0].annotations) { + if (a.key == "@Intent") hasIntent = true; + if (a.key == "@Contract") hasContract = true; + } + CHECK(hasIntent && hasContract, "missing key annotations"); + PASS(); +} + +void test_architect_review_can_modify_and_approve() { + TEST(architect_review_can_modify_and_approve); + auto st = runFlow( + "Build a REST API for a bookstore with user auth, PostgreSQL, and a React web frontend."); + bool changed = ArchitectReviewInterface::changeModuleLanguage(st, "api", "go"); + CHECK(changed, "expected language change"); + ArchitectReviewInterface::approve(st); + CHECK(st.approved, "expected approved state"); + PASS(); +} + +void test_workflow_created_after_approval() { + TEST(workflow_created_after_approval); + auto st = runFlow( + "Build a REST API for a bookstore with user auth, PostgreSQL, and a React web frontend."); + ArchitectReviewInterface::approve(st); + auto tasks = createWorkflow(st.skeleton); + CHECK(st.approved, "expected approved state"); + CHECK(!tasks.empty(), "expected workflow tasks"); + PASS(); +} + +void test_dependency_graph_available_in_review_snapshot() { + TEST(dependency_graph_available_in_review_snapshot); + auto st = runFlow( + "Build a REST API for a bookstore with user auth, PostgreSQL, and a React web frontend."); + auto snap = ArchitectReviewInterface::snapshot(st); + CHECK(!snap.dependencyGraph.empty(), "expected dependency graph"); + CHECK(!snap.modules.empty(), "expected module summaries"); + PASS(); +} + +void test_end_to_end_flow_keeps_review_structured_for_mcp() { + TEST(end_to_end_flow_keeps_review_structured_for_mcp); + auto st = runFlow( + "Build a REST API for a bookstore with user auth, PostgreSQL, and a React web frontend."); + auto snap = ArchitectReviewInterface::snapshot(st); + bool hasStackRationale = !snap.stackRationales.empty(); + bool hasModuleSummary = !snap.modules.empty(); + CHECK(hasStackRationale, "expected stack rationale entries"); + CHECK(hasModuleSummary, "expected module summary entries"); + PASS(); +} + +int main() { + std::cout << "Step 476: Phase 23a Integration Tests\n"; + + test_full_flow_extracts_structured_requirements(); // 1 + test_full_flow_decomposes_expected_modules(); // 2 + test_full_flow_stack_selects_frontend_and_database(); // 3 + test_full_flow_generates_skeleton_modules_and_annotations();// 4 + test_architect_review_can_modify_and_approve(); // 5 + test_workflow_created_after_approval(); // 6 + test_dependency_graph_available_in_review_snapshot(); // 7 + test_end_to_end_flow_keeps_review_structured_for_mcp(); // 8 + + std::cout << "\nResults: " << passed << "/" << (passed + failed) + << " passed\n"; + return failed == 0 ? 0 : 1; +} diff --git a/progress.md b/progress.md index 43b6a5c..7e18364 100644 --- a/progress.md +++ b/progress.md @@ -6620,3 +6620,46 @@ adjustment, approval). **Architecture gate check:** - `editor/src/ArchitectReviewInterface.h` within header-size limit (`231` <= `600`) - `editor/tests/step475_test.cpp` within test-file size guidance (`171` lines) + +### Step 476: Phase 23a Integration +**Status:** PASS (8/8 tests) + +Adds full Phase 23a integration coverage for architect mode: +problem description parsing → module decomposition → tech stack selection → +skeleton generation → architect review/approval → workflow task materialization. + +**Files added:** +- `editor/tests/step476_test.cpp` — 8 integration tests covering: + - end-to-end extraction/decomposition/selection flow for bookstore API scenario + - frontend/database stack expectation checks + - skeleton annotation presence checks + - architect review modifications + approval + - workflow task creation after approval + - dependency graph and structured review snapshot checks +- `editor/CMakeLists.txt` — `step476_test` target + +**Verification run:** +- `cmake --build editor/build-native --target step476_test` — PASS +- `./editor/build-native/step476_test` — PASS (8/8) +- `./editor/build-native/step475_test` — PASS (12/12) regression coverage + +**Architecture gate check:** +- `editor/tests/step476_test.cpp` within test-file size guidance (`148` lines) +- No new production header introduced in this integration step + +**Phase 23a totals (471-476):** +- **Steps:** 6 +- **Tests:** 68/68 passing +- **Headers added:** 5 + - `ArchitectProblemParser.h` + - `ArchitectModuleDecomposer.h` + - `ArchitectTechStackSelector.h` + - `ArchitectSkeletonGenerator.h` + - `ArchitectReviewInterface.h` +- **Capabilities delivered:** + - natural-language requirement extraction with confidence + - strategy-aware module decomposition graph generation + - per-module tech stack selection with preference overrides + - annotated multi-module skeleton generation + - architect review/modify/approve state model + - end-to-end architect-mode flow readiness for phase 23b scaffolding