diff --git a/editor/CMakeLists.txt b/editor/CMakeLists.txt index 16292d7..11f9df1 100644 --- a/editor/CMakeLists.txt +++ b/editor/CMakeLists.txt @@ -3361,4 +3361,13 @@ target_link_libraries(step497_test PRIVATE tree_sitter_javascript tree_sitter_typescript tree_sitter_java tree_sitter_rust tree_sitter_go) +add_executable(step498_test tests/step498_test.cpp) +target_include_directories(step498_test PRIVATE src) +target_link_libraries(step498_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/SelfHostingPhase25aIntegration.h b/editor/src/SelfHostingPhase25aIntegration.h new file mode 100644 index 0000000..65f3600 --- /dev/null +++ b/editor/src/SelfHostingPhase25aIntegration.h @@ -0,0 +1,49 @@ +#pragma once + +// Step 498: Phase 25a Integration +// Full self-hosting pipeline: parse -> annotate -> transpile -> workflow -> metrics. + +#include "SelfHostAnnotationAudit.h" +#include "SelfHostCodebaseAudit.h" +#include "SelfHostTranspileAudit.h" +#include "SelfHostingMetricsReport.h" +#include "SelfModernizationWorkflow.h" + +#include +#include + +struct Phase25aIntegrationResult { + CodebaseParseAudit parseAudit; + SelfAnnotationAuditReport annotationAudit; + SelfTranspileAuditReport transpileAudit; + ModernizationWorkflowReport workflowAudit; + SelfHostingMetrics metrics; + bool parseCoverageGate = false; // >=95% + bool transpileGate = false; // >=3 translated modules + bool workflowGate = false; // deterministic modernization viable + bool phasePass = false; + std::vector notes; +}; + +class SelfHostingPhase25aIntegration { +public: + static Phase25aIntegrationResult runCurrentState() { + Phase25aIntegrationResult out; + out.parseAudit = SelfHostCodebaseAudit::auditDirectories({"editor/src", "editor/src/ast"}); + out.annotationAudit = SelfHostAnnotationAudit::auditDirectories({"editor/src", "editor/src/ast"}); + out.transpileAudit = SelfHostTranspileAudit::runDefault(); + out.workflowAudit = SelfModernizationWorkflow::createAndRun("editor/src/AnnotationValidator.h"); + out.metrics = SelfHostingMetricsReport::generate( + out.parseAudit, out.annotationAudit, out.transpileAudit, out.workflowAudit); + + out.parseCoverageGate = out.parseAudit.meetsTarget(0.95); + out.transpileGate = static_cast(out.transpileAudit.files.size()) >= 3; + out.workflowGate = out.workflowAudit.deterministicCount == out.workflowAudit.deterministicValidCount; + out.phasePass = out.parseCoverageGate && out.transpileGate && out.workflowGate; + + out.notes.push_back("Phase 25a pipeline executed"); + out.notes.push_back(out.phasePass ? "Self-hosting thesis gate passed" + : "Self-hosting thesis gate has outstanding gaps"); + return out; + } +}; diff --git a/editor/tests/step498_test.cpp b/editor/tests/step498_test.cpp new file mode 100644 index 0000000..b33f325 --- /dev/null +++ b/editor/tests/step498_test.cpp @@ -0,0 +1,105 @@ +// Step 498: Phase 25a Integration Tests (8 tests) + +#include "SelfHostingPhase25aIntegration.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 Phase25aIntegrationResult runNow() { + return SelfHostingPhase25aIntegration::runCurrentState(); +} + +void test_full_pipeline_runs_parse_annotate_transpile_workflow_metrics() { + TEST(full_pipeline_runs_parse_annotate_transpile_workflow_metrics); + auto r = runNow(); + CHECK(r.parseAudit.totalFiles > 0, "parse audit missing"); + CHECK(r.annotationAudit.totalFiles > 0, "annotation audit missing"); + CHECK(!r.transpileAudit.files.empty(), "transpile audit missing"); + CHECK(!r.workflowAudit.tasks.empty(), "workflow audit missing"); + CHECK(r.metrics.filesTotal > 0, "metrics missing"); + PASS(); +} + +void test_parse_coverage_gate_uses_95_percent_threshold_semantics() { + TEST(parse_coverage_gate_uses_95_percent_threshold_semantics); + auto r = runNow(); + bool expected = r.parseAudit.parseRate() >= 0.95; + CHECK(r.parseCoverageGate == expected, "parse gate mismatch"); + PASS(); +} + +void test_transpile_gate_requires_at_least_three_headers() { + TEST(transpile_gate_requires_at_least_three_headers); + auto r = runNow(); + CHECK(r.transpileAudit.files.size() >= 3, "expected >=3 transpiled headers"); + CHECK(r.transpileGate, "transpile gate should pass"); + PASS(); +} + +void test_workflow_gate_requires_all_deterministic_outputs_valid() { + TEST(workflow_gate_requires_all_deterministic_outputs_valid); + auto r = runNow(); + bool expected = (r.workflowAudit.deterministicCount == r.workflowAudit.deterministicValidCount); + CHECK(r.workflowGate == expected, "workflow gate mismatch"); + PASS(); +} + +void test_phase_pass_equals_conjunction_of_all_gates() { + TEST(phase_pass_equals_conjunction_of_all_gates); + auto r = runNow(); + CHECK(r.phasePass == (r.parseCoverageGate && r.transpileGate && r.workflowGate), + "phase pass logic mismatch"); + PASS(); +} + +void test_metrics_consistency_with_underlying_reports() { + TEST(metrics_consistency_with_underlying_reports); + auto r = runNow(); + CHECK(r.metrics.filesTotal == r.parseAudit.totalFiles, "metrics parse total mismatch"); + CHECK(r.metrics.transpileReviewRequired == r.transpileAudit.reviewRequiredCount, + "metrics transpile review mismatch"); + CHECK(r.metrics.workflowTasks == (int)r.workflowAudit.tasks.size(), "metrics workflow task mismatch"); + PASS(); +} + +void test_notes_include_pipeline_execution_summary() { + TEST(notes_include_pipeline_execution_summary); + auto r = runNow(); + CHECK(!r.notes.empty(), "expected notes"); + CHECK(r.notes[0].find("pipeline executed") != std::string::npos, "missing execution note"); + PASS(); +} + +void test_phase_status_note_reflects_pass_or_gap_state() { + TEST(phase_status_note_reflects_pass_or_gap_state); + auto r = runNow(); + CHECK(r.notes.size() >= 2, "missing status note"); + if (r.phasePass) { + CHECK(r.notes[1].find("passed") != std::string::npos, "missing pass note"); + } else { + CHECK(r.notes[1].find("outstanding gaps") != std::string::npos, "missing gap note"); + } + PASS(); +} + +int main() { + std::cout << "Step 498: Phase 25a Integration Tests\n"; + + test_full_pipeline_runs_parse_annotate_transpile_workflow_metrics(); // 1 + test_parse_coverage_gate_uses_95_percent_threshold_semantics(); // 2 + test_transpile_gate_requires_at_least_three_headers(); // 3 + test_workflow_gate_requires_all_deterministic_outputs_valid(); // 4 + test_phase_pass_equals_conjunction_of_all_gates(); // 5 + test_metrics_consistency_with_underlying_reports(); // 6 + test_notes_include_pipeline_execution_summary(); // 7 + test_phase_status_note_reflects_pass_or_gap_state(); // 8 + + std::cout << "\nResults: " << passed << "/" << (passed + failed) + << " passed\n"; + return failed == 0 ? 0 : 1; +} diff --git a/progress.md b/progress.md index b2484c9..f0ead2e 100644 --- a/progress.md +++ b/progress.md @@ -7556,3 +7556,61 @@ single report with gap analysis. - `editor/src/SelfHostingMetricsReport.h` within header-size limit (`96` <= `600`) - `editor/tests/step497_test.cpp` within test-file size guidance (`165` lines) - Header-only architecture and naming conventions remain aligned with `ARCHITECTURE.md` + +### Step 498: Phase 25a Integration +**Status:** PASS (8/8 tests) + +Integrates the full Phase 25a self-hosting pipeline: +parse -> annotate -> transpile -> modernization workflow -> metrics, +with thesis-level gate checks for parse coverage, transpilation breadth, +and workflow viability. + +**Files added:** +- `editor/src/SelfHostingPhase25aIntegration.h` — phase integration composer: + - `Phase25aIntegrationResult` + - `runCurrentState()` executes: + - `SelfHostCodebaseAudit` + - `SelfHostAnnotationAudit` + - `SelfHostTranspileAudit` + - `SelfModernizationWorkflow` + - `SelfHostingMetricsReport` + - gate evaluation: + - parse coverage gate (`>=95%`) + - transpilation gate (`>=3` modules) + - workflow gate (all deterministic outputs valid) + - phase pass/fail synthesis + summary notes +- `editor/tests/step498_test.cpp` — 8 integration tests covering: + - full pipeline execution + - gate threshold semantics + - phase pass conjunction logic + - cross-report metric consistency + - integration note/status behavior +- `editor/CMakeLists.txt` — `step498_test` target + +**Verification run:** +- `cmake --build editor/build-native --target step498_test step497_test` — PASS +- `./editor/build-native/step498_test` — PASS (8/8) +- `./editor/build-native/step497_test` — PASS (12/12) regression coverage + +**Architecture gate check:** +- `editor/src/SelfHostingPhase25aIntegration.h` within header-size limit (`49` <= `600`) +- `editor/tests/step498_test.cpp` within test-file size guidance (`105` lines) +- Header-only architecture and naming conventions remain aligned with `ARCHITECTURE.md` + +**Phase 25a totals (493-498):** +- **Steps:** 6 +- **Tests:** 68/68 passing +- **Headers added:** 6 + - `SelfHostCodebaseAudit.h` + - `SelfHostAnnotationAudit.h` + - `SelfHostTranspileAudit.h` + - `SelfModernizationWorkflow.h` + - `SelfHostingMetricsReport.h` + - `SelfHostingPhase25aIntegration.h` +- **Capabilities delivered:** + - full-header parser coverage auditing across Whetstone source + - self-code annotation signal auditing + - targeted self-module transpilation auditing (Python/Rust/Java) + - self-modernization workflow routing + deterministic output validation + - consolidated self-host metrics/gap analysis + - phase-level self-hosting thesis gate evaluation