diff --git a/editor/CMakeLists.txt b/editor/CMakeLists.txt index 8d79c89..f5d8f7a 100644 --- a/editor/CMakeLists.txt +++ b/editor/CMakeLists.txt @@ -4171,4 +4171,13 @@ target_link_libraries(step587_test PRIVATE tree_sitter_javascript tree_sitter_typescript tree_sitter_java tree_sitter_rust tree_sitter_go) +add_executable(step588_test tests/step588_test.cpp) +target_include_directories(step588_test PRIVATE src) +target_link_libraries(step588_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/Phase33aIntegration.h b/editor/src/Phase33aIntegration.h new file mode 100644 index 0000000..d1c12b1 --- /dev/null +++ b/editor/src/Phase33aIntegration.h @@ -0,0 +1,94 @@ +#pragma once +// Step 588: Phase 33a Integration + +#include "CapabilityDiscoveryPanels.h" +#include "GuidedArchitectExecutionDemoMode.h" +#include "ValueForwardOnboardingFlow.h" +#include "WorkflowVisualizationV2.h" + +#include +#include + +struct Phase33aResult { + bool onboardingReady = false; + bool visualizationReady = false; + bool capabilityPanelReady = false; + bool demoModeReady = false; + bool phase33aPass = false; + std::vector notes; +}; + +class Phase33aIntegration { +public: + static Phase33aResult run() { + Phase33aResult result; + std::string error; + + OnboardingFlowState onboarding; + if (ValueForwardOnboardingFlow::start("default-profile", &onboarding, &error)) { + ValueForwardOnboardingFlow::completeCurrent(&onboarding, &error); + result.onboardingReady = !ValueForwardOnboardingFlow::valueHighlights(onboarding).empty(); + } else { + result.notes.push_back("fail:onboarding"); + return finalize(result); + } + + WorkflowVisualizationGraph graph; + result.visualizationReady = + WorkflowVisualizationV2::addNode(&graph, {"intake", WorkflowNodeKind::Intake, "Intake", "#2F7BFF"}, &error) && + WorkflowVisualizationV2::addNode(&graph, {"review", WorkflowNodeKind::ReviewGate, "Review", "#2F7BFF"}, &error) && + WorkflowVisualizationV2::addEdge(&graph, {"edge-1", "intake", "review", "Ambiguity triggers review gate"}, &error) && + !WorkflowVisualizationV2::plainLanguageRoutingSummary(graph).empty(); + if (!result.visualizationReady) { + result.notes.push_back("fail:visualization"); + return finalize(result); + } + + CapabilityDiscoveryPanels panels; + result.capabilityPanelReady = + panels.registerCategory("mcp", "MCP Tools", &error) && + panels.recordOperation("mcp", &error) && + panels.addRecommendation("mcp", "Try constrained execution demo", &error) && + panels.operationCountFor("mcp") == 1; + if (!result.capabilityPanelReady) { + result.notes.push_back("fail:capability_panels"); + return finalize(result); + } + + DemoModeState demo; + IntakeQueueSimulationInput input; + input.markdown = R"(## Goals +- Show end-to-end value +## Constraints +- Enable deterministic parser behavior +## Dependencies +- CMake +## Acceptance Criteria +- Queue includes bound acceptance checks +)"; + if (!GuidedArchitectExecutionDemoMode::start(input, &demo, &error)) { + result.notes.push_back("fail:demo_start"); + return finalize(result); + } + result.demoModeReady = GuidedArchitectExecutionDemoMode::advance(&demo, &error) && + GuidedArchitectExecutionDemoMode::advance(&demo, &error) && + GuidedArchitectExecutionDemoMode::advance(&demo, &error); + if (!result.demoModeReady) { + result.notes.push_back("fail:demo_progression"); + return finalize(result); + } + + result.notes.push_back("phase33a:product_value_obvious_on_first_use"); + return finalize(result); + } + +private: + static Phase33aResult finalize(Phase33aResult result) { + result.phase33aPass = result.onboardingReady && + result.visualizationReady && + result.capabilityPanelReady && + result.demoModeReady; + if (!result.phase33aPass) result.notes.push_back("phase33a:blocked"); + return result; + } +}; diff --git a/editor/tests/step588_test.cpp b/editor/tests/step588_test.cpp new file mode 100644 index 0000000..e7f08fc --- /dev/null +++ b/editor/tests/step588_test.cpp @@ -0,0 +1,101 @@ +// Step 588: Phase 33a Integration (8 tests) + +#include "Phase33aIntegration.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 {} + +static bool hasNote(const Phase33aResult& r, const std::string& note) { + for (const auto& n : r.notes) if (n == note) return true; + return false; +} + +void test_full_phase33a_cycle_passes() { + TEST(full_phase33a_cycle_passes); + auto r = Phase33aIntegration::run(); + CHECK(r.phase33aPass, "phase should pass"); + CHECK(r.onboardingReady, "onboarding should be ready"); + CHECK(r.visualizationReady, "visualization should be ready"); + CHECK(r.capabilityPanelReady, "capability panel should be ready"); + CHECK(r.demoModeReady, "demo mode should be ready"); + CHECK(hasNote(r, "phase33a:product_value_obvious_on_first_use"), "success note missing"); + PASS(); +} + +void test_onboarding_ready_signal_true_on_pass() { + TEST(onboarding_ready_signal_true_on_pass); + auto r = Phase33aIntegration::run(); + CHECK(r.phase33aPass, "phase should pass"); + CHECK(r.onboardingReady, "onboarding should be true"); + PASS(); +} + +void test_visualization_ready_signal_true_on_pass() { + TEST(visualization_ready_signal_true_on_pass); + auto r = Phase33aIntegration::run(); + CHECK(r.phase33aPass, "phase should pass"); + CHECK(r.visualizationReady, "visualization should be true"); + PASS(); +} + +void test_capability_panel_ready_signal_true_on_pass() { + TEST(capability_panel_ready_signal_true_on_pass); + auto r = Phase33aIntegration::run(); + CHECK(r.phase33aPass, "phase should pass"); + CHECK(r.capabilityPanelReady, "capability panel should be true"); + PASS(); +} + +void test_demo_mode_ready_signal_true_on_pass() { + TEST(demo_mode_ready_signal_true_on_pass); + auto r = Phase33aIntegration::run(); + CHECK(r.phase33aPass, "phase should pass"); + CHECK(r.demoModeReady, "demo mode should be true"); + PASS(); +} + +void test_no_blocked_note_on_success() { + TEST(no_blocked_note_on_success); + auto r = Phase33aIntegration::run(); + CHECK(r.phase33aPass, "phase should pass"); + CHECK(!hasNote(r, "phase33a:blocked"), "blocked note should be absent"); + PASS(); +} + +void test_notes_include_only_success_path_marker() { + TEST(notes_include_only_success_path_marker); + auto r = Phase33aIntegration::run(); + CHECK(r.phase33aPass, "phase should pass"); + CHECK(r.notes.size() == 1, "exactly one success note expected"); + PASS(); +} + +void test_phase_flag_matches_component_conjunction() { + TEST(phase_flag_matches_component_conjunction); + auto r = Phase33aIntegration::run(); + const bool conjunction = r.onboardingReady && r.visualizationReady && + r.capabilityPanelReady && r.demoModeReady; + CHECK(r.phase33aPass == conjunction, "phase flag should equal component conjunction"); + PASS(); +} + +int main() { + std::cout << "Step 588: Phase 33a Integration\n"; + + test_full_phase33a_cycle_passes(); // 1 + test_onboarding_ready_signal_true_on_pass(); // 2 + test_visualization_ready_signal_true_on_pass(); // 3 + test_capability_panel_ready_signal_true_on_pass(); // 4 + test_demo_mode_ready_signal_true_on_pass(); // 5 + test_no_blocked_note_on_success(); // 6 + test_notes_include_only_success_path_marker(); // 7 + test_phase_flag_matches_component_conjunction(); // 8 + + std::cout << "\nResults: " << passed << "/" << (passed + failed) << " passed\n"; + return failed == 0 ? 0 : 1; +} diff --git a/progress.md b/progress.md index 90f183b..50c293e 100644 --- a/progress.md +++ b/progress.md @@ -11089,3 +11089,40 @@ review, queue, constrained edits, and verification stages. - `editor/src/GuidedArchitectExecutionDemoMode.h` within header-size limit (`95` <= `600`) - `editor/tests/step587_test.cpp` within test-file size guidance (`182` lines) - Header-only architecture and naming conventions remain aligned with `ARCHITECTURE.md` + +### Step 588: Phase 33a Integration +**Status:** PASS (8/8 tests) + +Integrates Phase 33a product-experience components into a single first-use +readiness gate for onboarding value visibility. + +**Files added:** +- `editor/src/Phase33aIntegration.h` - Phase 33a integration module: + - onboarding flow readiness check + - workflow visualization readiness check + - capability panel readiness check + - guided demo-mode progression check + - phase pass synthesis with success/blocking notes +- `editor/tests/step588_test.cpp` - 8 tests covering: + - full phase pass path + - component readiness signal behavior + - note emission behavior + - phase flag conjunction behavior + +**Files modified:** +- `editor/CMakeLists.txt` - `step588_test` target + +**Verification run:** +- `cmake -S editor -B editor/build-native` - PASS +- `cmake --build editor/build-native --target step588_test step587_test` - PASS +- `./editor/build-native/step588_test` - PASS (8/8) +- `./editor/build-native/step587_test` - PASS (12/12) regression coverage + +**Architecture gate check:** +- `editor/src/Phase33aIntegration.h` within header-size limit (`94` <= `600`) +- `editor/tests/step588_test.cpp` within test-file size guidance (`101` lines) +- Header-only architecture and naming conventions remain aligned with `ARCHITECTURE.md` + +**Phase 33a totals (584-588):** +- **Steps completed:** 5 +- **New tests in this phase plan:** 56/56 passing