diff --git a/editor/CMakeLists.txt b/editor/CMakeLists.txt index 22f3ab0..29603f5 100644 --- a/editor/CMakeLists.txt +++ b/editor/CMakeLists.txt @@ -3739,4 +3739,13 @@ target_link_libraries(step539_test PRIVATE tree_sitter_javascript tree_sitter_typescript tree_sitter_java tree_sitter_rust tree_sitter_go) +add_executable(step540_test tests/step540_test.cpp) +target_include_directories(step540_test PRIVATE src) +target_link_libraries(step540_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/PythonTypeScriptConstructiveEditAdapter.h b/editor/src/PythonTypeScriptConstructiveEditAdapter.h new file mode 100644 index 0000000..3fa91e3 --- /dev/null +++ b/editor/src/PythonTypeScriptConstructiveEditAdapter.h @@ -0,0 +1,84 @@ +#pragma once +// Step 540: Python/TypeScript Constructive Edit Adapter + +#include +#include +#include + +struct PyTsConstructiveEditRequest { + std::string language; // python/typescript + std::string constructKind; // function/class/import/signature/module_stmt + std::string operation; + bool moduleSideEffectRisk = false; +}; + +struct PyTsConstructiveEditResult { + bool supported = false; + bool allowed = false; + std::vector legalOperations; + std::vector diagnostics; +}; + +class PythonTypeScriptConstructiveEditAdapter { +public: + static PyTsConstructiveEditResult evaluate(const PyTsConstructiveEditRequest& request) { + PyTsConstructiveEditResult result; + if (request.language != "python" && request.language != "typescript") { + result.diagnostics.push_back("unsupported_language"); + return result; + } + + result.supported = true; + result.legalOperations = legalOps(request.constructKind); + if (result.legalOperations.empty()) { + result.supported = false; + result.diagnostics.push_back("unsupported_construct"); + return result; + } + + if (!contains(result.legalOperations, request.operation)) { + result.diagnostics.push_back("operation_not_legal_for_construct"); + return result; + } + + auto sideEffect = sideEffectGuard(request); + if (!sideEffect.empty()) { + result.diagnostics.push_back(sideEffect); + return result; + } + + result.allowed = true; + return result; + } + +private: + static std::vector legalOps(const std::string& kind) { + if (kind == "function") return {"rename", "update", "extract", "inline"}; + if (kind == "class") return {"rename", "update", "extract"}; + if (kind == "import") return {"insert", "delete", "reorder"}; + if (kind == "signature") return {"update", "extract"}; + if (kind == "module_stmt") return {"update", "delete"}; + return {}; + } + + static std::string sideEffectGuard(const PyTsConstructiveEditRequest& request) { + // Module-level side effects: block destructive/reorder ops when flagged risky. + if (!request.moduleSideEffectRisk) return ""; + + if (request.constructKind == "import" && request.operation == "reorder") { + return "module_side_effect_reorder_blocked"; + } + if (request.constructKind == "module_stmt" && request.operation == "delete") { + return "module_side_effect_delete_blocked"; + } + if (request.constructKind == "function" && request.operation == "inline") { + return "module_side_effect_inline_blocked"; + } + return ""; + } + + static bool contains(const std::vector& values, + const std::string& value) { + return std::set(values.begin(), values.end()).count(value) != 0; + } +}; diff --git a/editor/tests/step540_test.cpp b/editor/tests/step540_test.cpp new file mode 100644 index 0000000..8a0e28e --- /dev/null +++ b/editor/tests/step540_test.cpp @@ -0,0 +1,126 @@ +// Step 540: Python/TypeScript Constructive Edit Adapter (12 tests) + +#include "PythonTypeScriptConstructiveEditAdapter.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 hasDiag(const PyTsConstructiveEditResult& r, const std::string& d) { + for (const auto& x : r.diagnostics) if (x == d) return true; + return false; +} + +void test_python_function_rename_allowed() { + TEST(python_function_rename_allowed); + auto r = PythonTypeScriptConstructiveEditAdapter::evaluate({"python", "function", "rename", false}); + CHECK(r.supported && r.allowed, "python function rename should be allowed"); + PASS(); +} + +void test_python_class_extract_allowed() { + TEST(python_class_extract_allowed); + auto r = PythonTypeScriptConstructiveEditAdapter::evaluate({"python", "class", "extract", false}); + CHECK(r.allowed, "python class extract should be allowed"); + PASS(); +} + +void test_typescript_import_reorder_allowed_without_side_effect_risk() { + TEST(typescript_import_reorder_allowed_without_side_effect_risk); + auto r = PythonTypeScriptConstructiveEditAdapter::evaluate({"typescript", "import", "reorder", false}); + CHECK(r.allowed, "ts import reorder should be allowed when risk false"); + PASS(); +} + +void test_typescript_import_reorder_blocked_with_side_effect_risk() { + TEST(typescript_import_reorder_blocked_with_side_effect_risk); + auto r = PythonTypeScriptConstructiveEditAdapter::evaluate({"typescript", "import", "reorder", true}); + CHECK(!r.allowed, "ts import reorder should be blocked when risk true"); + CHECK(hasDiag(r, "module_side_effect_reorder_blocked"), "side-effect diag expected"); + PASS(); +} + +void test_module_stmt_delete_blocked_with_side_effect_risk() { + TEST(module_stmt_delete_blocked_with_side_effect_risk); + auto r = PythonTypeScriptConstructiveEditAdapter::evaluate({"python", "module_stmt", "delete", true}); + CHECK(!r.allowed, "module stmt delete should be blocked with risk"); + CHECK(hasDiag(r, "module_side_effect_delete_blocked"), "side-effect delete diag expected"); + PASS(); +} + +void test_function_inline_blocked_with_side_effect_risk() { + TEST(function_inline_blocked_with_side_effect_risk); + auto r = PythonTypeScriptConstructiveEditAdapter::evaluate({"python", "function", "inline", true}); + CHECK(!r.allowed, "inline should be blocked with module risk"); + CHECK(hasDiag(r, "module_side_effect_inline_blocked"), "side-effect inline diag expected"); + PASS(); +} + +void test_signature_update_allowed() { + TEST(signature_update_allowed); + auto r = PythonTypeScriptConstructiveEditAdapter::evaluate({"typescript", "signature", "update", false}); + CHECK(r.allowed, "signature update should be allowed"); + PASS(); +} + +void test_signature_rename_not_legal() { + TEST(signature_rename_not_legal); + auto r = PythonTypeScriptConstructiveEditAdapter::evaluate({"typescript", "signature", "rename", false}); + CHECK(!r.allowed, "signature rename should be illegal"); + CHECK(hasDiag(r, "operation_not_legal_for_construct"), "illegal op diag expected"); + PASS(); +} + +void test_import_delete_allowed_without_side_effect_risk() { + TEST(import_delete_allowed_without_side_effect_risk); + auto r = PythonTypeScriptConstructiveEditAdapter::evaluate({"python", "import", "delete", false}); + CHECK(r.allowed, "import delete should be allowed when risk false"); + PASS(); +} + +void test_unsupported_construct_rejected() { + TEST(unsupported_construct_rejected); + auto r = PythonTypeScriptConstructiveEditAdapter::evaluate({"python", "decorator_stack", "update", false}); + CHECK(!r.supported, "unsupported construct should not be supported"); + CHECK(hasDiag(r, "unsupported_construct"), "unsupported construct diag expected"); + PASS(); +} + +void test_unsupported_language_rejected() { + TEST(unsupported_language_rejected); + auto r = PythonTypeScriptConstructiveEditAdapter::evaluate({"cpp", "function", "rename", false}); + CHECK(!r.supported, "unsupported language should fail"); + CHECK(hasDiag(r, "unsupported_language"), "unsupported language diag expected"); + PASS(); +} + +void test_typescript_function_extract_allowed() { + TEST(typescript_function_extract_allowed); + auto r = PythonTypeScriptConstructiveEditAdapter::evaluate({"typescript", "function", "extract", false}); + CHECK(r.allowed, "ts function extract should be allowed"); + PASS(); +} + +int main() { + std::cout << "Step 540: Python/TypeScript Constructive Edit Adapter\n"; + + test_python_function_rename_allowed(); // 1 + test_python_class_extract_allowed(); // 2 + test_typescript_import_reorder_allowed_without_side_effect_risk(); // 3 + test_typescript_import_reorder_blocked_with_side_effect_risk();// 4 + test_module_stmt_delete_blocked_with_side_effect_risk(); // 5 + test_function_inline_blocked_with_side_effect_risk(); // 6 + test_signature_update_allowed(); // 7 + test_signature_rename_not_legal(); // 8 + test_import_delete_allowed_without_side_effect_risk(); // 9 + test_unsupported_construct_rejected(); // 10 + test_unsupported_language_rejected(); // 11 + test_typescript_function_extract_allowed(); // 12 + + std::cout << "\nResults: " << passed << "/" << (passed + failed) << " passed\n"; + return failed == 0 ? 0 : 1; +} diff --git a/progress.md b/progress.md index a340d48..148b394 100644 --- a/progress.md +++ b/progress.md @@ -9181,3 +9181,35 @@ operation mapping and header/source boundary safety checks. - `editor/src/CppConstructiveEditAdapter.h` within header-size limit (`90` <= `600`) - `editor/tests/step539_test.cpp` within test-file size guidance (`126` lines) - Header-only architecture and naming conventions remain aligned with `ARCHITECTURE.md` + +### Step 540: Python/TypeScript Constructive Edit Adapter +**Status:** PASS (12/12 tests) + +Implements Python/TypeScript constructive edit adaptation with construct-aware +legal operation mappings and module-level side-effect protection guards. + +**Files added:** +- `editor/src/PythonTypeScriptConstructiveEditAdapter.h` - Python/TypeScript adapter module: + - legal operation mappings for functions/classes/imports/signatures/module statements + - shared support for both `python` and `typescript` + - module side-effect risk guardrails for reorder/delete/inline-sensitive paths + - structured diagnostics for unsupported constructs/languages and illegal ops +- `editor/tests/step540_test.cpp` - 12 tests covering: + - legal operation paths across Python/TypeScript constructs + - side-effect risk blocking behavior + - illegal operation rejections for constrained constructs + - unsupported construct/language behavior + +**Files modified:** +- `editor/CMakeLists.txt` - `step540_test` target + +**Verification run:** +- `cmake -S editor -B editor/build-native` - PASS +- `cmake --build editor/build-native --target step540_test step539_test` - PASS +- `./editor/build-native/step540_test` - PASS (12/12) +- `./editor/build-native/step539_test` - PASS (12/12) regression coverage + +**Architecture gate check:** +- `editor/src/PythonTypeScriptConstructiveEditAdapter.h` within header-size limit (`84` <= `600`) +- `editor/tests/step540_test.cpp` within test-file size guidance (`126` lines) +- Header-only architecture and naming conventions remain aligned with `ARCHITECTURE.md`