statable 3.1.0__py3-none-any.whl

codegen/validate/validation_dialog.py

@@ -0,0 +1,322 @@
+# statable_gui/validation_dialog.py
+"""\nValidation / AI integration dialog\nPySide6 compatible\n"""
+
+import sys
+import os
+import json
+import logging
+
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+sys.path.append(os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))), 'codegen'))
+
+from PySide6.QtWidgets import (
+    QDialog, QVBoxLayout, QHBoxLayout, QPushButton,
+    QLabel, QTextEdit, QTreeWidget, QTreeWidgetItem,
+    QMessageBox, QTabWidget, QWidget, QGroupBox,
+    QFormLayout, QComboBox, QSplitter
+)
+from PySide6.QtCore import Qt
+
+from .validator import CodeGenerationValidator
+from .prompt_generator import AIPromptGenerator
+from .response_parser import AIResponseParser
+from .change_applier import ChangeApplier
+from .clipboard_manager import ClipboardManager
+from .response_validator import ResponseValidator
+from .models import ValidationResult
+
+logging.basicConfig(level=logging.DEBUG, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
+logger = logging.getLogger("validation_dialog")
+
+
+class ValidationDialog(QDialog):
+    """Validation / AI integration dialog"""
+    
+    def __init__(self, sm, gd, parent=None):
+        super().__init__(parent)
+        self.sm = sm
+        self.gd = gd
+        self.validator = CodeGenerationValidator()
+        self.prompt_generator = AIPromptGenerator()
+        self.response_parser = AIResponseParser()
+        self.response_validator = ResponseValidator()
+        self.clipboard = ClipboardManager()
+        self.validation_result = None
+        self.parsed_changes = []
+        self.validation_outcome = None
+        
+        self.setWindowTitle("Pre-generation validation / AI diagnosis")
+        self.setMinimumSize(900, 700)
+        
+        self._setup_ui()
+        self._run_validation()
+    
+    def _setup_ui(self):
+        """Build UI"""
+        main_layout = QVBoxLayout(self)
+        
+        # Tab widget
+        self.tab_widget = QTabWidget()
+        main_layout.addWidget(self.tab_widget)
+        
+        # ===== Validation result tab =====
+        self.validation_tab = QWidget()
+        self._setup_validation_tab()
+        self.tab_widget.addTab(self.validation_tab, "1) Validation result")
+        
+        # ===== AI prompt tab =====
+        self.prompt_tab = QWidget()
+        self._setup_prompt_tab()
+        self.tab_widget.addTab(self.prompt_tab, "2) AI prompt")
+        
+        # ===== AI answer tab =====
+        self.response_tab = QWidget()
+        self._setup_response_tab()
+        self.tab_widget.addTab(self.response_tab, "3) AI answer intake")
+        
+        # ===== Change list tab =====
+        self.changes_tab = QWidget()
+        self._setup_changes_tab()
+        self.tab_widget.addTab(self.changes_tab, "4) Change list / apply")
+        
+        # Close button
+        button_layout = QHBoxLayout()
+        close_btn = QPushButton("Close")
+        close_btn.clicked.connect(self.accept)
+        button_layout.addStretch()
+        button_layout.addWidget(close_btn)
+        main_layout.addLayout(button_layout)
+    
+    def _setup_validation_tab(self):
+        """Set up the validation result tab"""
+        layout = QVBoxLayout(self.validation_tab)
+        
+        # Summary label
+        self.summary_label = QLabel("")
+        self.summary_label.setStyleSheet("font-weight: bold; font-size: 14px;")
+        layout.addWidget(self.summary_label)
+        
+        # Problem list
+        self.issue_tree = QTreeWidget()
+        self.issue_tree.setHeaderLabels(["Severity", "Category", "Message", "Target", "Suggested fix"])
+        self.issue_tree.setColumnWidth(0, 80)
+        self.issue_tree.setColumnWidth(1, 100)
+        self.issue_tree.setColumnWidth(2, 300)
+        self.issue_tree.setColumnWidth(3, 100)
+        self.issue_tree.setColumnWidth(4, 300)
+        layout.addWidget(self.issue_tree)
+        
+        # Re-validate button
+        revalidate_btn = QPushButton("Re-validate")
+        revalidate_btn.clicked.connect(self._run_validation)
+        layout.addWidget(revalidate_btn)
+    
+    def _setup_prompt_tab(self):
+        """Set up the AI prompt tab"""
+        layout = QVBoxLayout(self.prompt_tab)
+        
+        # Description label
+        info_label = QLabel(
+            "Perform AI diagnosis with the following steps:\n"
+            "1. Click \"Copy\" button to copy the prompt to the clipboard\n"
+            "2. Paste into ChatGPT or similar and ask\n"
+            "3. Copy the AI answer\n"
+            "4. Paste the answer in the \"AI answer intake\" tab"
+        )
+        info_label.setWordWrap(True)
+        layout.addWidget(info_label)
+        
+        # Copy button
+        copy_btn = QPushButton("Copy prompt")
+        copy_btn.clicked.connect(self._copy_prompt)
+        layout.addWidget(copy_btn)
+        
+        # Prompt preview
+        self.prompt_preview = QTextEdit()
+        self.prompt_preview.setReadOnly(True)
+        layout.addWidget(self.prompt_preview)
+    
+    def _setup_response_tab(self):
+        """Set up the AI answer tab"""
+        layout = QVBoxLayout(self.response_tab)
+        
+        # Paste button
+        paste_btn = QPushButton("Paste from clipboard")
+        paste_btn.clicked.connect(self._paste_response)
+        layout.addWidget(paste_btn)
+        
+        # Answer input
+        self.response_edit = QTextEdit()
+        self.response_edit.setPlaceholderText("Paste the AI answer here")
+        layout.addWidget(self.response_edit)
+        
+        # Parse button
+        parse_btn = QPushButton("Parse the answer and generate a change list")
+        parse_btn.clicked.connect(self._parse_response)
+        layout.addWidget(parse_btn)
+    
+    def _setup_changes_tab(self):
+        """Set up the change list tab"""
+        layout = QVBoxLayout(self.changes_tab)
+        
+        # Change list
+        self.change_tree = QTreeWidget()
+        self.change_tree.setHeaderLabels([
+            "Selection", "Action", "Parameter", "Reason",
+            "Priority", "Confidence", "Status",
+        ])
+        self.change_tree.setColumnWidth(0, 50)
+        self.change_tree.setColumnWidth(1, 150)
+        self.change_tree.setColumnWidth(2, 400)
+        self.change_tree.setColumnWidth(3, 250)
+        self.change_tree.setColumnWidth(4, 80)
+        self.change_tree.setColumnWidth(5, 80)
+        self.change_tree.setColumnWidth(6, 240)
+        layout.addWidget(self.change_tree)
+        
+        # Apply button
+        apply_btn = QPushButton("Apply selected changes")
+        apply_btn.clicked.connect(self._apply_changes)
+        layout.addWidget(apply_btn)
+    
+    def _run_validation(self):
+        """Run validation"""
+        logger.debug("_run_validation started")
+        self.validation_result = self.validator.validate(self.sm, self.gd)
+        
+        # Summary update
+        summary = (f"Error: {self.validation_result.error_count} | "
+                  f"Warning: {self.validation_result.warning_count} | "
+                  f"Info: {self.validation_result.info_count}")
+        self.summary_label.setText(summary)
+        
+        # Problem list update
+        self.issue_tree.clear()
+        severity_colors = {
+            'error': Qt.red,
+            'warning': Qt.yellow,
+            'info': Qt.blue,
+        }
+        
+        for issue in self.validation_result.issues:
+            item = QTreeWidgetItem([
+                issue.severity.value.upper(),
+                issue.category,
+                issue.message,
+                issue.target,
+                issue.suggestion,
+            ])
+            # Severity-based coloring
+            color = severity_colors.get(issue.severity.value, Qt.black)
+            item.setForeground(0, color)
+            self.issue_tree.addTopLevelItem(item)
+        
+        # Prompt generation
+        prompt = self.prompt_generator.generate_diagnosis_prompt(
+            self.sm, self.gd, self.validation_result
+        )
+        self.prompt_preview.setPlainText(prompt)
+        
+        logger.debug(f"_run_validation completed: {summary}")
+    
+    def _copy_prompt(self):
+        """Copy prompt to clipboard"""
+        prompt = self.prompt_generator.generate_diagnosis_prompt(
+            self.sm, self.gd, self.validation_result
+        )
+        if self.clipboard.copy_to_clipboard(prompt):
+            QMessageBox.information(self, "Copy complete",
+                "Prompt copied to clipboard.\n"
+                "Please paste into ChatGPT or similar and ask.")
+        else:
+            QMessageBox.warning(self, "Error", "Failed to copy to clipboard.")
+    
+    def _paste_response(self):
+        """Paste AI answer from clipboard"""
+        text = self.clipboard.get_from_clipboard()
+        if text:
+            self.response_edit.setPlainText(text)
+        else:
+            QMessageBox.warning(self, "Warning", "Clipboard is empty.")
+    
+    def _parse_response(self):
+        """Parse AI answer"""
+        text = self.response_edit.toPlainText()
+        if not text.strip():
+            QMessageBox.warning(self, "Warning", "AI answer is empty.")
+            return
+        
+        parsed = self.response_parser.parse(text)
+        self.validation_outcome = self.response_validator.validate(
+            parsed, self.sm, self.gd)
+        outcome = self.validation_outcome
+        self.parsed_changes = list(outcome.valid_requests)
+        
+        # Show change list (valid requests only)
+        self.change_tree.clear()
+        for change in self.parsed_changes:
+            item = QTreeWidgetItem()
+            item.setFlags(item.flags() | Qt.ItemIsUserCheckable)
+            item.setCheckState(0, Qt.Checked)
+            item.setText(1, change.action.value)
+            item.setText(2, json.dumps(change.params, ensure_ascii=False))
+            item.setText(3, change.reason)
+            item.setText(4, change.priority)
+            item.setText(5, f"{change.confidence:.2f}")
+            item.setText(6, "OK")
+            self.change_tree.addTopLevelItem(item)
+        
+        # Append invalid requests as unchecked, disabled rows
+        for req, reason in outcome.invalid_requests:
+            item = QTreeWidgetItem()
+            # Non-checkable, non-selectable: an excluded
+            # proposal must not participate in 'apply selected'.
+            item.setFlags(Qt.ItemIsEnabled)
+            item.setText(0, "")
+            item.setText(1, req.action.value)
+            item.setText(2, json.dumps(req.params, ensure_ascii=False))
+            item.setText(3, req.reason)
+            item.setText(4, req.priority)
+            item.setText(5, f"{req.confidence:.2f}")
+            item.setText(6, f"EXCLUDED: {reason}")
+            self.change_tree.addTopLevelItem(item)
+        
+        # Switch the tab to the change list
+        self.tab_widget.setCurrentIndex(3)
+        
+        n_ok = len(outcome.valid_requests)
+        n_ng = len(outcome.invalid_requests)
+        msg = f"Parsed {len(parsed)} change(s).\n"
+        msg += f"Valid: {n_ok}   Excluded: {n_ng}\n"
+        if outcome.warnings:
+            msg += "\nWarnings:\n" + "\n".join(
+                f"  * {w}" for w in outcome.warnings)
+        QMessageBox.information(self, "Parse complete", msg)
+    
+    def _apply_changes(self):
+        """Apply selected changes"""
+        selected_changes = []
+        for i in range(self.change_tree.topLevelItemCount()):
+            item = self.change_tree.topLevelItem(i)
+            if item.checkState(0) == Qt.Checked:
+                selected_changes.append(self.parsed_changes[i])
+        
+        if not selected_changes:
+            QMessageBox.warning(self, "Warning", "No changes selected for applying.")
+            return
+        
+        applier = ChangeApplier(self.sm, self.gd)
+        result = applier.apply_all(selected_changes)
+        
+        QMessageBox.information(self, "Apply complete",
+            f"{result['applied']} change(s) applied.\n"
+            f"Failed: {result['failed']} item(s)")
+        
+        # Re-validate
+        self._run_validation()
+
+
+def show_validation_dialog(sm, gd, parent=None):
+    """Helper function to show the validation dialog"""
+    dialog = ValidationDialog(sm, gd, parent)
+    dialog.exec()

codegen/validate/validator.py

@@ -0,0 +1,94 @@
+# codegen/validate/validator.py
+"""Validation main class."""
+
+import sys
+import os
+from typing import List, Dict, Type
+
+sys.path.append(os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))))
+
+# Logger referenced directly
+from .logger import logger
+
+# Model
+from .models import ValidationResult, ValidationIssue, ValidationContext
+
+# Validators
+from .items.state_validator import StateValidator
+from .items.event_validator import EventValidator
+from .items.transition_validator import TransitionValidator
+from .items.role_function_validator import RoleFunctionValidator
+from .items.variable_validator import VariableValidator
+from .items.flag_validator import FlagValidator
+from .items.queue_validator import QueueValidator
+from .items.interrupt_validator import InterruptValidator
+from .items.timer_validator import TimerValidator
+from .items.custom_type_validator import CustomTypeValidator
+from .items.cell_validator import CellValidator
+
+
+class CodeGenerationValidator:
+    """Code generation validation main class"""
+
+    VALIDATORS: Dict[str, Type] = {
+        'state': StateValidator,
+        'event': EventValidator,
+        'transition': TransitionValidator,
+        'role_function': RoleFunctionValidator,
+        'variable': VariableValidator,
+        'flag': FlagValidator,
+        'queue': QueueValidator,
+        'interrupt': InterruptValidator,
+        'timer': TimerValidator,
+        'custom_type': CustomTypeValidator,
+        'cell': CellValidator,
+    }
+
+    def __init__(self):
+        logger.debug("CodeGenerationValidator.__init__ started")
+        self._validators = {}
+        for category, validator_class in self.VALIDATORS.items():
+            logger.debug(f"Creating validator: {category} -> {validator_class.__name__}")
+            self._validators[category] = validator_class()
+        logger.debug(f"CodeGenerationValidator.__init__ completed: "
+                     f"{len(self._validators)} validators")
+
+    def validate(self, state_machine, global_defs) -> ValidationResult:
+        logger.debug(f"validate started: sm_id={id(state_machine)}, gd_id={id(global_defs)}")
+
+        context = ValidationContext(
+            state_machine=state_machine,
+            global_defs=global_defs,
+        )
+
+        result = ValidationResult()
+
+        for category, validator in self._validators.items():
+            logger.debug(f"Running validator: {category}")
+            try:
+                issues = validator.validate(context)
+                result.issues.extend(issues)
+            except Exception as e:
+                logger.error(f"Validator '{category}' failed: {e}", exc_info=True)
+
+        logger.debug(f"validate completed: errors={result.error_count}, "
+                     f"warnings={result.warning_count}, infos={result.info_count}")
+        return result
+
+    def validate_category(self, category: str, state_machine, global_defs
+                          ) -> List[ValidationIssue]:
+        logger.debug(f"validate_category: {category}")
+        validator = self._validators.get(category)
+        if validator is None:
+            logger.warning(f"Unknown category: {category}")
+            return []
+
+        context = ValidationContext(
+            state_machine=state_machine,
+            global_defs=global_defs,
+        )
+
+        return validator.validate(context)
+
+    def get_categories(self) -> List[str]:
+        return list(self._validators.keys())