ed/manual_slop
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

chore(conductor): Archive completed track 'MMA Core Engine Implementation'

Browse Source
This commit is contained in:
Edward R. Gonzalez
2026-02-26 22:02:33 -05:00
parent 332fc4d774
commit 716d8b4e13
16 changed files with 578 additions and 24 deletions
Download Patch File Download Diff File Expand all files Collapse all files

11
tests/temp_project_history.toml
View File

@@ -5,10 +5,17 @@ roles = [
"System",
"Reasoning",
]
active = "main"
active = "mma_human veriffication"
auto_add = true
[discussions.main]
git_commit = ""
last_updated = "2026-02-26T21:34:07"
last_updated = "2026-02-26T22:00:42"
history = [
"@2026-02-26T22:00:02\nSystem:\n[PERFORMANCE ALERT] CPU usage high: 92.2%. Please consider optimizing recent changes or reducing load.",
]
[discussions."mma_human veriffication"]
git_commit = ""
last_updated = "2026-02-26T22:02:01"
history = []

96
tests/verify_mma_gui_robust.py Normal file
View File

@@ -0,0 +1,96 @@
import subprocess
import time
import sys
import os
import unittest
# Calculate project root
PROJECT_ROOT = os.path.abspath(os.path.join(os.path.dirname(__file__), '..'))
if PROJECT_ROOT not in sys.path:
sys.path.insert(0, PROJECT_ROOT)
from api_hook_client import ApiHookClient
class TestMMAGUIRobust(unittest.TestCase):
@classmethod
def setUpClass(cls):
# 1. Launch gui_2.py with --enable-test-hooks
cls.gui_command = [sys.executable, "gui_2.py", "--enable-test-hooks"]
print(f"Launching GUI: {' '.join(cls.gui_command)}")
cls.gui_process = subprocess.Popen(
cls.gui_command,
cwd=PROJECT_ROOT,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
text=True
)
cls.client = ApiHookClient()
print("Waiting for GUI to start...")
if not cls.client.wait_for_server(timeout=10):
cls.gui_process.terminate()
raise RuntimeError("GUI failed to start or hook server not responsive.")
print("GUI started.")
@classmethod
def tearDownClass(cls):
if cls.gui_process:
cls.gui_process.terminate()
cls.gui_process.wait(timeout=5)
def test_mma_state_ingestion(self):
"""Verify that mma_state_update event correctly updates GUI state."""
track_data = {
"id": "robust_test_track",
"title": "Robust Verification Track",
"description": "Verifying internal state ingestion"
}
tickets_data = [
{"id": "T1", "target_file": "file1.py", "status": "todo"},
{"id": "T2", "target_file": "file2.py", "status": "running"},
{"id": "T3", "target_file": "file3.py", "status": "complete"},
]
payload = {
"status": "active",
"active_tier": "Tier 2",
"track": track_data,
"tickets": tickets_data
}
print("Pushing mma_state_update...")
self.client.push_event("mma_state_update", payload)
# Give GUI a moment to process the async task
time.sleep(1.0)
print("Querying mma_status...")
status = self.client.get_mma_status()
self.assertEqual(status["mma_status"], "active")
self.assertEqual(status["active_tier"], "Tier 2")
self.assertEqual(status["active_track"]["id"], "robust_test_track")
self.assertEqual(len(status["active_tickets"]), 3)
self.assertEqual(status["active_tickets"][2]["status"], "complete")
print("MMA state ingestion verified successfully.")
def test_mma_step_approval_trigger(self):
"""Verify that mma_step_approval event sets the pending approval flag."""
payload = {
"ticket_id": "T2",
"payload": "echo 'Robust Test'"
}
print("Pushing mma_step_approval...")
self.client.push_event("mma_step_approval", payload)
time.sleep(1.0)
print("Querying mma_status for pending approval...")
status = self.client.get_mma_status()
self.assertTrue(status["pending_approval"], "GUI did not register pending MMA approval")
print("MMA step approval trigger verified successfully.")
if __name__ == "__main__":
unittest.main()

69
tests/visual_diag.py Normal file
View File

@@ -0,0 +1,69 @@
import subprocess
import time
import sys
import os
PROJECT_ROOT = os.path.abspath(os.path.join(os.path.dirname(__file__), '..'))
if PROJECT_ROOT not in sys.path:
sys.path.insert(0, PROJECT_ROOT)
from api_hook_client import ApiHookClient
def diag_run():
print("Launching GUI for manual inspection + automated hooks...")
# Use a log file for GUI output
with open("gui_diag.log", "w") as log_file:
gui_process = subprocess.Popen(
[sys.executable, "gui_2.py", "--enable-test-hooks"],
cwd=PROJECT_ROOT,
stdout=log_file,
stderr=log_file,
text=True
)
client = ApiHookClient()
print("Waiting for GUI...")
if not client.wait_for_server(timeout=10):
print("GUI failed to start.")
gui_process.terminate()
return
# Pushing state
track_data = {"id": "diag_track", "title": "Diagnostic Track"}
tickets_data = [{"id": f"T{i}", "status": "todo"} for i in range(3)]
print("Pushing state update...")
client.push_event("mma_state_update", {
"status": "active",
"active_tier": "Tier 1",
"track": track_data,
"tickets": tickets_data
})
time.sleep(2)
print("Pushing approval request...")
client.push_event("mma_step_approval", {
"ticket_id": "T0",
"payload": "Get-ChildItem"
})
print("\nGUI is running. Check 'gui_diag.log' for output.")
print("I will now poll mma_status every 2 seconds. Ctrl+C to stop.")
try:
start_poll = time.time()
while time.time() - start_poll < 30:
try:
status = client.get_mma_status()
print(f"[{time.strftime('%H:%M:%S')}] Status: {status.get('mma_status')}, Pending Approval: {status.get('pending_approval')}")
except Exception as e:
print(f"[{time.strftime('%H:%M:%S')}] Error querying status: {e}")
time.sleep(2)
except KeyboardInterrupt:
print("Stopping...")
finally:
gui_process.terminate()
if __name__ == "__main__":
diag_run()

184
tests/visual_mma_verification.py Normal file
View File

@@ -0,0 +1,184 @@
import subprocess
import time
import sys
import os
import glob # Will be used to find api_hook_client.py path if needed, though sys.path modification is better.
# --- Configuration ---
GUI_SCRIPT = 'gui_2.py'
TEST_HOOKS_FLAG = '--enable-test-hooks'
API_HOOK_CLIENT_MODULE = 'api_hook_client'
PROJECT_ROOT = os.path.abspath(os.path.join(os.path.dirname(__file__), '..')) # Calculate project root
# Ensure project root is in sys.path to import modules like api_hook_client
if PROJECT_ROOT not in sys.path:
sys.path.insert(0, PROJECT_ROOT)
print(f"Added '{PROJECT_ROOT}' to sys.path for imports.")
try:
from api_hook_client import ApiHookClient
except ImportError as e:
print(f"Error: Could not import ApiHookClient from '{API_HOOK_CLIENT_MODULE}'.")
print(f"Please ensure '{API_HOOK_CLIENT_MODULE}.py' is accessible and '{PROJECT_ROOT}' is correctly added to sys.path.")
print(f"Import error: {e}")
sys.exit(1)
def run_visual_mma_verification():
print("Starting visual MMA verification test...")
# Change current directory to project root to ensure relative paths are correct for gui_2.py
original_dir = os.getcwd()
if original_dir != PROJECT_ROOT:
try:
os.chdir(PROJECT_ROOT)
print(f"Changed current directory to: {PROJECT_ROOT}")
except FileNotFoundError:
print(f"Error: Project root directory '{PROJECT_ROOT}' not found.")
return
# 1. Launch gui_2.py with --enable-test-hooks
gui_command = [sys.executable, GUI_SCRIPT, TEST_HOOKS_FLAG]
print(f"Launching GUI with command: {' '.join(gui_command)}")
try:
gui_process = subprocess.Popen(
gui_command,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
text=True,
cwd=PROJECT_ROOT # Explicitly set working directory
)
print(f"GUI process started with PID: {gui_process.pid}")
except FileNotFoundError:
print(f"Error: Could not find Python executable '{sys.executable}' or script '{GUI_SCRIPT}'.")
return
except Exception as e:
print(f"Error starting GUI process: {e}")
return
# Give the GUI a moment to start and open the hook server.
print("Waiting for GUI to initialize and hook server to start (5 seconds)...")
time.sleep(5)
# Check if the GUI process exited prematurely
if gui_process.poll() is not None:
print(f"Error: GUI process exited prematurely with return code {gui_process.returncode}.")
stderr_output = gui_process.stderr.read()
if stderr_output:
print("--- GUI Stderr ---")
print(stderr_output)
print("------------------")
return
# 2. Use api_hook_client.ApiHookClient to push events
try:
client = ApiHookClient()
print("ApiHookClient initialized successfully.")
except Exception as e:
print(f"Failed to initialize ApiHookClient. Ensure the hook server is running on port 8999. Error: {e}")
if gui_process:
gui_process.terminate()
gui_process.wait()
return
# 3. Include at least 5 tickets in different states
track_data = {
"id": "visual_test_track",
"title": "Visual Verification Track",
"description": "A track to verify MMA UI components"
}
tickets_data = [
{"id": "TICKET-001", "target_file": "core.py", "status": "todo"},
{"id": "TICKET-002", "target_file": "utils.py", "status": "running"},
{"id": "TICKET-003", "target_file": "tests.py", "status": "complete"},
{"id": "TICKET-004", "target_file": "api.py", "status": "blocked"},
{"id": "TICKET-005", "target_file": "gui.py", "status": "paused"},
]
print("\nPushing MMA state update...")
try:
payload = {
"status": "running",
"active_tier": "Tier 3",
"track": track_data,
"tickets": tickets_data
}
client.push_event("mma_state_update", payload)
print(" - MMA state update pushed.")
except Exception as e:
print(f" - Warning: Failed to push mma_state_update: {e}")
# 4. After a short delay, push an 'mma_step_approval' event
print("\nWaiting for GUI to render ticket queue and progress bar (3 seconds)...")
time.sleep(3)
print("Pushing 'mma_step_approval' event to trigger HITL modal...")
try:
approval_payload = {
"ticket_id": "TICKET-002",
"payload": "powershell -Command \"Write-Host 'Hello from Tier 3'\""
}
client.push_event("mma_step_approval", approval_payload)
print("mma_step_approval event pushed successfully.")
except Exception as e:
print(f"Error pushing mma_step_approval event: {e}")
# 5. Provide clear print statements for manual verification
print("
--- Manual Verification Instructions ---")
print("Please visually inspect the running GUI application:")
print("1. MMA Dashboard: Ensure the 'MMA Dashboard' panel is visible and active.")
print("2. Ticket Queue: Verify the 'Ticket Queue' section displays all 5 tickets with correct statuses:")
print(" - TICKET-001: Should be 'todo'")
print(" - TICKET-002: Should be 'running'")
print(" - TICKET-003: Should be 'complete'")
print(" - TICKET-004: Should be 'blocked'")
print(" - TICKET-005: Should be 'paused'")
print(" Observe the distinct status colors for each ticket.")
print("3. Progress Bar: Check that the progress bar correctly reflects the completed/total tickets (e.g., 1/5).")
print("4. Approval Modal: Confirm that an 'MMA Step Approval' modal has appeared.")
print(" - Verify it contains a 'Proposed Tool Call' section (e.g., showing 'powershell -Command...').")
print(" - Ensure there is an option/button to 'Edit Payload'.")
print("
--------------------------------------")
print("The test script has finished its automated actions.")
print("The GUI application is still running. Please perform manual verification.")
print("Press Enter in this terminal to stop the GUI process and exit the test script.")
try:
input()
except EOFError:
print("EOF received, exiting.")
pass
print("
Stopping GUI process...")
if gui_process:
try:
gui_process.terminate()
gui_process.wait(timeout=10)
print("GUI process terminated gracefully.")
except subprocess.TimeoutExpired:
print("GUI process did not terminate within the timeout. Killing it forcefully.")
gui_process.kill()
gui_process.wait()
except Exception as e:
print(f"Error during GUI process termination: {e}")
else:
print("GUI process was not started or already terminated.")
print("Visual MMA verification test script finished.")
# Restore original directory
if original_dir != PROJECT_ROOT:
try:
os.chdir(original_dir)
print(f"Restored original working directory: {original_dir}")
except FileNotFoundError:
print(f"Warning: Could not restore original working directory '{original_dir}'.")
# --- Main execution ---
if __name__ == "__main__":
# When the script is executed directly, ensure it runs from the correct context.
run_visual_mma_verification()