statable 3.1.0__py3-none-any.whl

codegen/type_mapper.py

@@ -0,0 +1,69 @@
+# codegen/type_mapper.py
+"""
+C language type mapping module (dictionary-driven)
+"""
+
+import sys
+import os
+from typing import Set, List
+
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+try:
+    from .code_templates import CodeTemplates
+except ImportError:
+    from code_templates import CodeTemplates
+
+
+class CTypeMapper:
+    """Class mapping StaTable types to C language types"""
+    
+    TYPE_MAPPING = {
+        'int': 'int', 'int8': 'int8_t', 'int16': 'int16_t',
+        'int32': 'int32_t', 'int64': 'int64_t',
+        'uint': 'unsigned int', 'uint8': 'uint8_t', 'uint16': 'uint16_t',
+        'uint32': 'uint32_t', 'uint64': 'uint64_t',
+        'float': 'float', 'double': 'double', 'bool': 'bool',
+        'char': 'char', 'string': 'char*', 'void': 'void',
+    }
+    
+    TYPE_CATEGORIES = {
+        'int': 'integer', 'int8': 'integer', 'int16': 'integer',
+        'int32': 'integer', 'int64': 'integer',
+        'uint': 'integer', 'uint8': 'integer', 'uint16': 'integer',
+        'uint32': 'integer', 'uint64': 'integer',
+        'float': 'float', 'double': 'float', 'bool': 'boolean',
+        'char': 'character', 'string': 'string', 'void': 'void',
+    }
+    
+    HEADER_REQUIREMENTS = {
+        'integer': '#include <stdint.h>',
+        'boolean': '#include <stdbool.h>',
+        'string': '#include <string.h>',
+        'float': '#include <math.h>',
+    }
+    
+    def __init__(self):
+        self.templates = CodeTemplates()
+        self.strings = self.templates.STRINGS
+        self.formats = self.templates.FORMATS
+    
+    @classmethod
+    def map_type(cls, sta_type):
+        return cls.TYPE_MAPPING.get(sta_type, sta_type)
+    
+    @classmethod
+    def get_type_category(cls, sta_type):
+        return cls.TYPE_CATEGORIES.get(sta_type, 'custom')
+    
+    @classmethod
+    def get_required_headers(cls, types):
+        headers = set()
+        categories = set()
+        for type_name in types:
+            categories.add(cls.get_type_category(type_name))
+        for category in categories:
+            header = cls.HEADER_REQUIREMENTS.get(category)
+            if header:
+                headers.add(header)
+        return sorted(headers)

codegen/validate/__init__.py

@@ -0,0 +1,38 @@
+# codegen/validate/__init__.py
+"""\nValidation / AI integration package\n"""
+
+from .logger import logger, setup_logger
+from .models import (
+    ValidationSeverity,
+    ValidationIssue,
+    ValidationResult,
+    ValidationContext,
+)
+from .validator import CodeGenerationValidator
+from .prompt_generator import AIPromptGenerator
+from .response_parser import AIResponseParser
+from .change_actions import ChangeRequest, ChangeActionType
+from .change_applier import ChangeApplier
+from .clipboard_manager import ClipboardManager
+from .response_validator import (
+    ResponseValidator,
+    ResponseValidationResult,
+)
+
+__all__ = [
+    'logger',
+    'setup_logger',
+    'ValidationSeverity',
+    'ValidationIssue',
+    'ValidationResult',
+    'ValidationContext',
+    'CodeGenerationValidator',
+    'AIPromptGenerator',
+    'AIResponseParser',
+    'ChangeRequest',
+    'ChangeActionType',
+    'ChangeApplier',
+    'ClipboardManager',
+    'ResponseValidator',
+    'ResponseValidationResult',
+]

codegen/validate/change_actions.py

@@ -0,0 +1,90 @@
+# codegen/validate/change_actions.py
+"""
+Change action definitions.
+
+[v2.2 §12-6 change]
+  - Added 7 cell-level AI action types:
+      ADD_CELL / REMOVE_CELL
+      ADD_ACTION_STEP / REMOVE_ACTION_STEP
+      ADD_TRANSITION_RELATION / REMOVE_TRANSITION_RELATION
+      SET_EARLY_RETURN
+"""
+
+from enum import Enum
+from dataclasses import dataclass, field
+from typing import Dict, Any, List
+
+
+class ChangeActionType(Enum):
+    """Change action kind"""
+    # --------------------------------------------------------------
+    # Legacy actions
+    # --------------------------------------------------------------
+    SET_INITIAL = "set_initial"
+    ADD_TRANSITION = "add_transition"
+    ADD_STATE = "add_state"
+    ADD_EVENT = "add_event"
+    REMOVE_TRANSITION = "remove_transition"
+    UPDATE_TRANSITION = "update_transition"
+    ADD_ROLE_FUNCTION = "add_role_function"
+    REMOVE_ROLE_FUNCTION = "remove_role_function"
+    ADD_VARIABLE = "add_variable"
+    ADD_FLAG = "add_flag"
+
+    # --------------------------------------------------------------
+    # v2.2 §12-6: Cell-level AI action extensions
+    # --------------------------------------------------------------
+    ADD_CELL = "add_cell"
+    REMOVE_CELL = "remove_cell"
+    ADD_ACTION_STEP = "add_action_step"
+    REMOVE_ACTION_STEP = "remove_action_step"
+    ADD_TRANSITION_RELATION = "add_transition_relation"
+    REMOVE_TRANSITION_RELATION = "remove_transition_relation"
+    SET_EARLY_RETURN = "set_early_return"
+
+
+@dataclass
+class ChangeRequest:
+    """Change request"""
+    action: ChangeActionType
+    params: Dict[str, Any] = field(default_factory=dict)
+    reason: str = ""
+    source: str = "ai"
+    # [v2.8.0 Phase B] extended fields
+    id: str = ""
+    evidence: List[str] = field(default_factory=list)
+    priority: str = "medium"
+    confidence: float = 1.0
+
+    def to_dict(self) -> Dict:
+        return {
+            'id': self.id,
+            'action': self.action.value,
+            'params': self.params,
+            'reason': self.reason,
+            'source': self.source,
+            'evidence': list(self.evidence),
+            'priority': self.priority,
+            'confidence': self.confidence,
+        }
+
+    @classmethod
+    def from_dict(cls, data: Dict) -> 'ChangeRequest':
+        try:
+            confidence = float(data.get('confidence', 1.0))
+        except (TypeError, ValueError):
+            confidence = 1.0
+        return cls(
+            action=ChangeActionType(data['action']),
+            params=data.get('params', {}),
+            reason=data.get('reason', ''),
+            source=data.get('source', 'ai'),
+            id=str(data.get('id', '') or ''),
+            evidence=list(data.get('evidence', []) or []),
+            priority=str(data.get('priority', 'medium') or 'medium'),
+            confidence=confidence,
+        )
+
+    def __str__(self) -> str:
+        return (f"ChangeRequest(action={self.action.value}, "
+                f"params={self.params}, reason={self.reason})")

codegen/validate/change_applier.py

@@ -0,0 +1,416 @@
+# codegen/validate/change_applier.py
+"""
+Change apply engine.
+
+[v1.6 change]
+  - Added 'remove_role_function' to _handlers
+
+[v2.2 §12-6 change]
+  - Added 7 cell-level AI action handlers:
+      _add_cell / _remove_cell
+      _add_action_step / _remove_action_step
+      _add_transition_relation / _remove_transition_relation
+      _set_early_return
+"""
+
+import sys
+import os
+from typing import List, Dict, Tuple
+
+sys.path.append(os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))))
+
+from .logger import logger
+from .change_actions import ChangeRequest, ChangeActionType
+
+
+class ChangeApplier:
+    """Apply change requests to a StateMachine / GlobalDefinitions."""
+
+    def __init__(self, sm, gd):
+        logger.debug("ChangeApplier.__init__ started")
+        self.sm = sm
+        self.gd = gd
+        self.applied_changes = []
+        self.failed_changes = []
+        # Define handler dict by string key
+        self._handlers = {
+            'set_initial': self._set_initial,
+            'add_transition': self._add_transition,
+            'add_state': self._add_state,
+            'add_event': self._add_event,
+            'remove_transition': self._remove_transition,
+            'update_transition': self._update_transition,
+            'add_role_function': self._add_role_function,
+            'remove_role_function': self._remove_role_function,
+            'add_variable': self._add_variable,
+            'add_flag': self._add_flag,
+            # v2.2 §12-6 additions
+            'add_cell': self._add_cell,
+            'remove_cell': self._remove_cell,
+            'add_action_step': self._add_action_step,
+            'remove_action_step': self._remove_action_step,
+            'add_transition_relation': self._add_transition_relation,
+            'remove_transition_relation': self._remove_transition_relation,
+            'set_early_return': self._set_early_return,
+        }
+        logger.debug("ChangeApplier.__init__ completed")
+
+    def apply(self, change: ChangeRequest) -> Tuple[bool, str]:
+        """Apply change"""
+        logger.debug(f"apply: action={change.action}")
+        action_value = (change.action.value
+                        if hasattr(change.action, 'value')
+                        else str(change.action))
+        logger.debug(f"action_value: {action_value}")
+
+        handler = self._handlers.get(action_value)
+        if handler is None:
+            logger.warning(f"Unsupported action: {action_value}")
+            return False, f"Unsupported action: {action_value}"
+
+        try:
+            result = handler(change.params)
+            if result[0]:
+                self.applied_changes.append(change)
+                logger.debug(f"Change applied: {action_value}")
+            else:
+                self.failed_changes.append((change, result[1]))
+                logger.warning(f"Change failed: {result[1]}")
+            return result
+        except Exception as e:
+            logger.error(f"Change threw exception: {e}", exc_info=True)
+            self.failed_changes.append((change, str(e)))
+            return False, str(e)
+
+    def apply_all(self, changes: List[ChangeRequest]) -> Dict:
+        """Apply all changes"""
+        logger.debug(f"apply_all: {len(changes)} changes")
+        results = []
+        for change in changes:
+            success, message = self.apply(change)
+            results.append({'change': change, 'success': success,
+                            'message': message})
+        summary = {
+            'total': len(changes),
+            'applied': len(self.applied_changes),
+            'failed': len(self.failed_changes),
+            'results': results,
+        }
+        logger.debug(
+            f"apply_all completed: applied={summary['applied']}, "
+            f"failed={summary['failed']}")
+        return summary
+
+    # ==================================================================
+    # Existing handlers (unchanged)
+    # ==================================================================
+    def _set_initial(self, params: Dict) -> Tuple[bool, str]:
+        state = params.get('state', '')
+        if state not in self.sm.states:
+            return False, f"State '{state}' does not exist"
+        self.sm.set_initial(state)
+        return True, f"Initial state set to '{state}'"
+
+    def _add_transition(self, params: Dict) -> Tuple[bool, str]:
+        from statable.model import Transition
+        source = params.get('source', '')
+        event = params.get('event', '')
+        target = params.get('target', '')
+        if not all([source, event, target]):
+            return False, "Transition information is incomplete"
+        transition = Transition(
+            source=source, event=event, target=target,
+            condition=params.get('condition', ''),
+            action=params.get('action_name', ''),
+        )
+        try:
+            self.sm.add_transition(transition)
+            return True, f"Transition '{source} --[{event}]--> {target}' added"
+        except ValueError as e:
+            return False, str(e)
+
+    def _add_state(self, params: Dict) -> Tuple[bool, str]:
+        from statable.model import State, StateType
+        name = params.get('name', '')
+        if not name:
+            return False, "State name is not specified"
+        if name in self.sm.states:
+            return False, f"State '{name}' already exists"
+        type_name = params.get('type', 'NORMAL')
+        state_type = getattr(StateType, type_name, StateType.NORMAL)
+        if not hasattr(StateType, type_name):
+            logger.warning(
+                f"_add_state: unknown type '{type_name}' -> NORMAL fallback")
+        parent = params.get('parent', None) or None
+        self.sm.add_state(State(
+            name=name, type=state_type, parent=parent,
+            description=params.get('description', ''),
+        ))
+        return True, f"State '{name}' added (type={state_type.name})"
+
+    def _add_event(self, params: Dict) -> Tuple[bool, str]:
+        from statable.model import Event, EventKind
+        name = params.get('name', '')
+        if not name:
+            return False, "Event name is not specified"
+        if name in self.sm.events:
+            return False, f"Event '{name}' already exists"
+        kind = getattr(EventKind, params.get('kind', 'SIGNAL'),
+                       EventKind.SIGNAL)
+        self.sm.add_event(Event(name=name, kind=kind,
+                                description=params.get('description', '')))
+        return True, f"Event '{name}' added"
+
+    def _remove_transition(self, params: Dict) -> Tuple[bool, str]:
+        source = params.get('source', '')
+        event = params.get('event', '')
+        target = params.get('target', '')
+        for t in self.sm.transitions:
+            if t.source == source and t.event == event and t.target == target:
+                self.sm.remove_transition(t)
+                return True, f"Transition '{source} --[{event}]--> {target}' deleted"
+        return False, "No matching transition found"
+
+    def _update_transition(self, params: Dict) -> Tuple[bool, str]:
+        source = params.get('source', '')
+        event = params.get('event', '')
+        for t in self.sm.transitions:
+            if t.source == source and t.event == event:
+                if 'new_target' in params:
+                    t.target = params['new_target']
+                if 'new_condition' in params:
+                    t.condition = params['new_condition']
+                if 'new_action' in params:
+                    t.action = params['new_action']
+                return True, f"Transition '{source} --[{event}]-->' updated"
+        return False, "No matching transition found"
+
+    def _add_role_function(self, params: Dict) -> Tuple[bool, str]:
+        from statable.model import RoleFunction
+        name = params.get('name', '')
+        if not name:
+            return False, "Function name is not specified"
+        if name in self.sm.role_functions:
+            return False, f"Function '{name}' already exists"
+        rf = RoleFunction(
+            name=name,
+            namespace=params.get('namespace', ''),
+            return_type=params.get('return_type', 'void'),
+            description=params.get('description', ''),
+        )
+        self.sm.add_role_function(rf)
+        return True, f"Role function '{name}' added"
+
+    def _remove_role_function(self, params: Dict) -> Tuple[bool, str]:
+        """
+        Remove a role function.
+
+        Added in v1.6. Corresponds to ChangeActionType.REMOVE_ROLE_FUNCTION.
+        params:
+          name: 'HandleErr' or 'Middleware.HandleErr' (either is acceptable)
+        """
+        name = params.get('name', '')
+        if not name:
+            return False, "Function name is not specified"
+        # Exact match
+        if name in self.sm.role_functions:
+            self.sm.remove_role_function(name)
+            return True, f"Role function '{name}' deleted"
+
+        # Match by qualified_name
+        for key, rf in list(self.sm.role_functions.items()):
+            qn = getattr(rf, 'qualified_name', None) or key
+            if qn == name:
+                self.sm.remove_role_function(key)
+                return True, f"Role function '{name}' deleted"
+
+        # Match by bare name
+        for key, rf in list(self.sm.role_functions.items()):
+            if getattr(rf, 'name', '') == name:
+                self.sm.remove_role_function(key)
+                return True, f"Role function '{name}' deleted"
+        return False, f"Function '{name}' not found"
+
+    def _add_variable(self, params: Dict) -> Tuple[bool, str]:
+        from statable.global_defs import SystemVariable
+        name = params.get('name', '')
+        if not name:
+            return False, "Variable 'name' is required"
+        # [C-28 fix] Duplicate check
+        if any(getattr(v, 'name', '') == name for v in self.gd.variables):
+            return False, f"Variable '{name}' already exists"
+        var = SystemVariable(
+            name=name, type=params.get('type', 'uint8'),
+            group=params.get('group', ''),
+            description=params.get('description', ''))
+        self.gd.variables.append(var)
+        return True, f"Variable '{name}' added"
+
+    def _add_flag(self, params: Dict) -> Tuple[bool, str]:
+        from statable.global_defs import EventFlag
+        name = params.get('name', '')
+        if not name:
+            return False, "Flag 'name' is required"
+        # [C-28 fix] Duplicate check
+        if any(getattr(f, 'name', '') == name for f in self.gd.flags):
+            return False, f"Flag '{name}' already exists"
+        flag = EventFlag(
+            name=name, min_value=params.get('min_value', 0),
+            max_value=params.get('max_value', 1),
+            group=params.get('group', ''))
+        self.gd.flags.append(flag)
+        return True, f"Flag '{name}' added"
+
+    # ==================================================================
+    # v2.2 §12-6: Cell-level handlers
+    # ==================================================================
+    def _add_cell(self, params: Dict) -> Tuple[bool, str]:
+        """Ensure a cell exists for (source, event). Idempotent."""
+        source = params.get('source', '')
+        event = params.get('event', '')
+        if source not in self.sm.states:
+            return False, f"Source state '{source}' does not exist"
+        # event may be '' for completion transitions
+        if event and event not in self.sm.events:
+            return False, f"Event '{event}' does not exist"
+        # Ensure cell_actions / cell_relations entries exist (may be empty lists)
+        self.sm.cell_actions.setdefault((source, event), [])
+        self.sm.cell_relations.setdefault((source, event), [])
+        return True, f"Cell ({source}, {event or 'Completion'}) ensured"
+
+    def _remove_cell(self, params: Dict) -> Tuple[bool, str]:
+        """Remove all cell-level metadata (actions + relations)."""
+        source = params.get('source', '')
+        event = params.get('event', '')
+        if source not in self.sm.states:
+            return False, f"Source state '{source}' does not exist"
+        self.sm.remove_cell_metadata(source, event)
+        return True, f"Cell ({source}, {event or 'Completion'}) removed"
+
+    def _add_action_step(self, params: Dict) -> Tuple[bool, str]:
+        from statable.model import ActionStep
+        source = params.get('source', '')
+        event = params.get('event', '')
+        role_function = params.get('role_function', '')
+        trigger = params.get('trigger', 'before_transitions')
+
+        if not role_function:
+            return False, "role_function is required"
+        if source not in self.sm.states:
+            return False, f"Source state '{source}' does not exist"
+        if event and event not in self.sm.events:
+            return False, f"Event '{event}' does not exist"
+        if trigger not in ('before_transitions', 'after_transitions'):
+            return False, f"Invalid trigger: {trigger}"
+
+        existing = list(self.sm.get_actions_for_cell(source, event))
+        existing.append(ActionStep(
+            role_function=role_function, trigger=trigger,
+            title=role_function,
+        ))
+        self.sm.set_actions_for_cell(source, event, existing)
+        return True, (f"Action step '{role_function}' ({trigger}) "
+                      f"added to ({source}, {event or 'Completion'})")
+
+    def _remove_action_step(self, params: Dict) -> Tuple[bool, str]:
+        source = params.get('source', '')
+        event = params.get('event', '')
+        role_function = params.get('role_function', '')
+
+        if not role_function:
+            return False, "role_function is required"
+        if source not in self.sm.states:
+            return False, f"Source state '{source}' does not exist"
+
+        existing = list(self.sm.get_actions_for_cell(source, event))
+        filtered = [a for a in existing if a.role_function != role_function]
+        if len(filtered) == len(existing):
+            return False, f"Action step '{role_function}' not found"
+        self.sm.set_actions_for_cell(source, event, filtered)
+        return True, (f"Action step '{role_function}' removed from "
+                      f"({source}, {event or 'Completion'})")
+
+    def _add_transition_relation(self, params: Dict) -> Tuple[bool, str]:
+        from statable.model import TransitionRelation
+        source = params.get('source', '')
+        event = params.get('event', '')
+        kind = params.get('kind', '')
+        members = params.get('members', [])
+        shared_condition = params.get('shared_condition', '')
+
+        if source not in self.sm.states:
+            return False, f"Source state '{source}' does not exist"
+        if event and event not in self.sm.events:
+            return False, f"Event '{event}' does not exist"
+        if kind not in ('sequential', 'exclusive', 'group'):
+            return False, f"Invalid kind: {kind}"
+        if not members:
+            return False, "members is required"
+        if kind == 'group' and not shared_condition:
+            return False, "shared_condition is required for kind == 'group'"
+
+        # Validate that labels exist in this cell
+        existing_labels = {getattr(t, 'label', '') or ''
+                           for t in self.sm.get_transitions_for_cell(source, event)}
+        for m in members:
+            if m not in existing_labels:
+                return False, f"Label '{m}' does not exist in this cell"
+
+        existing = list(self.sm.get_relations_for_cell(source, event))
+        existing.append(TransitionRelation(
+            kind=kind, members=list(members),
+            shared_condition=shared_condition,
+        ))
+        self.sm.set_relations_for_cell(source, event, existing)
+        return True, (f"Relation ({kind}) added to "
+                      f"({source}, {event or 'Completion'})")
+
+    def _remove_transition_relation(self, params: Dict) -> Tuple[bool, str]:
+        source = params.get('source', '')
+        event = params.get('event', '')
+        kind = params.get('kind', '')
+        shared_condition = params.get('shared_condition', None)
+
+        if source not in self.sm.states:
+            return False, f"Source state '{source}' does not exist"
+
+        existing = list(self.sm.get_relations_for_cell(source, event))
+        filtered = []
+        removed = False
+        for r in existing:
+            if removed:
+                filtered.append(r)
+                continue
+            kind_match = (r.kind == kind)
+            cond_match = (shared_condition is None
+                          or r.shared_condition == shared_condition)
+            if kind_match and cond_match:
+                removed = True
+                continue
+            filtered.append(r)
+
+        if not removed:
+            return False, f"No matching relation found (kind={kind})"
+        self.sm.set_relations_for_cell(source, event, filtered)
+        return True, (f"Relation ({kind}) removed from "
+                      f"({source}, {event or 'Completion'})")
+
+    def _set_early_return(self, params: Dict) -> Tuple[bool, str]:
+        source = params.get('source', '')
+        event = params.get('event', '')
+        label = params.get('label', '')
+        early_return = params.get('early_return', None)
+
+        if source not in self.sm.states:
+            return False, f"Source state '{source}' does not exist"
+        if not label:
+            return False, "label is required"
+        if early_return is None:
+            return False, "early_return is required"
+
+        for t in self.sm.get_transitions_for_cell(source, event):
+            if getattr(t, 'label', '') == label:
+                t.early_return = bool(early_return)
+                return True, (f"Transition '{label}' early_return set to "
+                              f"{t.early_return}")
+        return False, f"Transition label '{label}' not found in ({source}, {event or 'Completion'})"

codegen/validate/clipboard_manager.py

@@ -0,0 +1,47 @@
+# codegen/validate/clipboard_manager.py
+"""Clipboard management (PySide6 only)."""
+
+import os
+import sys
+
+sys.path.append(
+    os.path.dirname(
+        os.path.dirname(
+            os.path.dirname(os.path.abspath(__file__)))))
+
+from .logger import logger
+
+
+class ClipboardManager:
+    """Clipboard management class."""
+
+    @staticmethod
+    def copy_to_clipboard(text: str) -> bool:
+        logger.debug(f"copy_to_clipboard: {len(text)} chars")
+        try:
+            from PySide6.QtWidgets import QApplication
+        except ImportError:
+            logger.error("PySide6 not available")
+            return False
+
+        try:
+            QApplication.clipboard().setText(text)
+            return True
+        except Exception as e:
+            logger.error(f"Clipboard set failed: {e}")
+            return False
+
+    @staticmethod
+    def get_from_clipboard() -> str:
+        logger.debug("get_from_clipboard started")
+        try:
+            from PySide6.QtWidgets import QApplication
+        except ImportError:
+            logger.error("PySide6 not available")
+            return ""
+
+        try:
+            return QApplication.clipboard().text()
+        except Exception as e:
+            logger.error(f"Clipboard get failed: {e}")
+            return ""