comptext-codex 5.0.0__py3-none-any.whl

comptext_codex/executor.py

@@ -0,0 +1,248 @@
+"""CompText DSL Executor - Executes parsed CompText commands."""
+
+from typing import Any, Dict, List, Optional, Callable
+from dataclasses import dataclass
+import logging
+
+from .parser import CompTextCommand, CompTextParser
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class ExecutionResult:
+    """Result of command execution."""
+    success: bool
+    result: Any
+    error: Optional[str] = None
+    metadata: Dict[str, Any] = None
+
+    def __post_init__(self):
+        if self.metadata is None:
+            self.metadata = {}
+
+
+class CompTextExecutor:
+    """Executes CompText commands by dispatching to appropriate modules."""
+
+    def __init__(self, codex_dir: Optional[str] = None):
+        """Initialize executor.
+
+        Args:
+            codex_dir: Path to codex directory for loading definitions (legacy)
+        """
+        self.codex_dir = codex_dir
+        self.parser = CompTextParser(codex_dir=codex_dir)
+        self._module_instances: Dict[str, Any] = {}
+        self._command_handlers: Dict[str, Callable] = {}
+        self._registry = None
+        self._load_modules()
+
+    def _load_modules(self):
+        """Load modules via the auto-registration registry."""
+        try:
+            from .registry import ensure_modules_loaded, registry
+            ensure_modules_loaded()
+            self._registry = registry
+            # Pre-populate instances for all registered modules
+            for code in registry.list_module_codes():
+                self._module_instances[code] = registry.get_instance(code)
+            logger.debug("Loaded %d modules from registry", len(self._module_instances))
+        except ImportError as e:
+            logger.warning("Failed to load registry, falling back to legacy: %s", e)
+            self._load_modules_legacy()
+
+    def _load_modules_legacy(self):
+        """Fallback: Dynamically load module implementations via importlib."""
+        import importlib
+        for code in "ABCDEFGHIJKLM":
+            try:
+                module_name = f"comptext_codex.modules.module_{code.lower()}"
+                module = importlib.import_module(module_name)
+                if hasattr(module, "get_module"):
+                    self._module_instances[code] = module.get_module()
+                else:
+                    self._module_instances[code] = module
+            except ImportError as e:
+                logger.debug("Module %s not implemented: %s", code, e)
+                self._module_instances[code] = None
+
+    def execute(self, command_string: str, context: Optional[Dict[str, Any]] = None) -> List[ExecutionResult]:
+        """Execute CompText command(s).
+
+        Args:
+            command_string: Raw CompText command(s)
+            context: Optional execution context with variables
+
+        Returns:
+            List of execution results for each command
+
+        Examples:
+            >>> executor = CompTextExecutor()
+            >>> results = executor.execute("@A:compress The quick brown fox")
+            >>> print(results[0].result)
+        """
+        context = context or {}
+
+        # Parse commands
+        commands = self.parser.parse(command_string)
+
+        if not commands:
+            return [ExecutionResult(
+                success=False,
+                result=None,
+                error="Failed to parse command"
+            )]
+
+        # Execute each command in sequence
+        results = []
+        execution_context = context.copy()
+
+        for cmd in commands:
+            result = self._execute_single(cmd, execution_context)
+            results.append(result)
+
+            # Update context with result for chained commands
+            if result.success:
+                execution_context['_last_result'] = result.result
+
+        return results
+
+    def _execute_single(self, cmd: CompTextCommand, context: Dict[str, Any]) -> ExecutionResult:
+        """Execute a single command.
+
+        Args:
+            cmd: Parsed command
+            context: Execution context
+
+        Returns:
+            Execution result
+        """
+        try:
+            # Get module instance (from registry or legacy)
+            module = self._module_instances.get(cmd.module)
+
+            if module is None:
+                return self._execute_fallback(cmd, context)
+
+            # Find command handler
+            handler_name = f"execute_{cmd.command.lower()}"
+
+            if hasattr(module, handler_name):
+                handler = getattr(module, handler_name)
+                result = handler(*cmd.args, context=context, **cmd.kwargs)
+
+                return ExecutionResult(
+                    success=True,
+                    result=result,
+                    metadata={
+                        'module': cmd.module,
+                        'command': cmd.command
+                    }
+                )
+            elif hasattr(module, 'execute'):
+                # Generic execute method
+                try:
+                    result = module.execute(cmd, context)
+                    return ExecutionResult(
+                        success=True,
+                        result=result,
+                        metadata={
+                            'module': cmd.module,
+                            'command': cmd.command
+                        }
+                    )
+                except NotImplementedError:
+                    return self._execute_fallback(cmd, context)
+            else:
+                return self._execute_fallback(cmd, context)
+
+        except Exception as e:
+            logger.error(f"Error executing {cmd.module}:{cmd.command}: {e}")
+            return ExecutionResult(
+                success=False,
+                result=None,
+                error=str(e),
+                metadata={
+                    'module': cmd.module,
+                    'command': cmd.command
+                }
+            )
+
+    def _execute_fallback(self, cmd: CompTextCommand, context: Dict[str, Any]) -> ExecutionResult:
+        """Fallback execution for unimplemented commands.
+
+        Returns a mock result that describes what would be executed.
+        """
+        return ExecutionResult(
+            success=True,
+            result={
+                'status': 'simulated',
+                'message': f"Command {cmd.module}:{cmd.command} would execute with args={cmd.args}, kwargs={cmd.kwargs}",
+                'module': cmd.module,
+                'command': cmd.command,
+                'args': cmd.args,
+                'kwargs': cmd.kwargs
+            },
+            metadata={
+                'simulated': True,
+                'module': cmd.module,
+                'command': cmd.command
+            }
+        )
+
+    def register_handler(self, module: str, command: str, handler: Callable):
+        """Register a custom command handler.
+
+        Args:
+            module: Module code (A-M)
+            command: Command name
+            handler: Callable that executes the command
+        """
+        key = f"{module}:{command}"
+        self._command_handlers[key] = handler
+
+    def get_available_commands(self) -> List[Dict[str, Any]]:
+        """Get list of available commands.
+
+        Returns:
+            List of command metadata dictionaries
+        """
+        # Prefer registry metadata (includes descriptions, aliases, etc.)
+        if self._registry is not None:
+            return [cmd.to_dict() for cmd in self._registry.all_command_meta()]
+
+        # Fallback: introspect module instances
+        commands = []
+        for module_code, module in self._module_instances.items():
+            if module is None:
+                continue
+            if hasattr(module, "get_commands"):
+                commands.extend(module.get_commands())
+            else:
+                for attr_name in dir(module):
+                    if attr_name.startswith("execute_"):
+                        command_name = attr_name[8:]
+                        commands.append({
+                            "module": module_code,
+                            "command": command_name,
+                            "syntax": f"@{module_code}:{command_name}",
+                        })
+        return commands
+
+
+# Convenience function
+def execute(command_string: str, context: Optional[Dict[str, Any]] = None,
+            codex_dir: Optional[str] = None) -> List[ExecutionResult]:
+    """Execute CompText command(s).
+
+    Args:
+        command_string: Raw CompText command(s)
+        context: Optional execution context
+        codex_dir: Optional path to codex directory
+
+    Returns:
+        List of execution results
+    """
+    executor = CompTextExecutor(codex_dir=codex_dir)
+    return executor.execute(command_string, context=context)

comptext_codex/mcp_server_v5.py

@@ -0,0 +1,343 @@
+"""CompText V5.0 ULTRA MCP Server Implementation."""
+
+import json
+from typing import Any, Dict, List, Optional
+from dataclasses import dataclass, asdict
+
+try:
+    from mcp import Server, Tool, types
+    MCP_AVAILABLE = True
+except ImportError:
+    MCP_AVAILABLE = False
+    # Fallback for when MCP is not installed
+    class Server:
+        pass
+    class Tool:
+        pass
+
+from .parser_v5 import CompTextParserV5, CompTextCommandV5
+
+
+@dataclass
+class MCPToolResult:
+    """Result from an MCP tool execution."""
+    success: bool
+    data: Any
+    error: Optional[str] = None
+    metadata: Optional[Dict[str, Any]] = None
+
+
+class CompTextMCPServer:
+    """MCP Server for CompText V5.0 ULTRA Protocol.
+
+    Provides tools for parsing, encoding, and analyzing V5.0 ULTRA commands
+    through the Model Context Protocol.
+    """
+
+    def __init__(self):
+        """Initialize MCP server."""
+        if not MCP_AVAILABLE:
+            raise ImportError("MCP package not installed. Install with: pip install mcp")
+
+        self.parser = CompTextParserV5()
+        self.server = Server("comptext-v5-ultra")
+
+        # Register tools
+        self._register_tools()
+
+    def _register_tools(self):
+        """Register MCP tools."""
+
+        @self.server.tool(
+            name="parse_v5",
+            description="Parse a CompText V5.0 ULTRA command into structured format",
+            parameters={
+                "command": {
+                    "type": "string",
+                    "description": "V5.0 ULTRA command to parse (e.g., 'C;P:FIB' or 'B:[D:SUM]|[C;P:FIB]')"
+                }
+            }
+        )
+        async def parse_v5(command: str) -> Dict[str, Any]:
+            """Parse V5.0 ULTRA command."""
+            try:
+                results = self.parser.parse(command)
+
+                commands = []
+                for cmd in results:
+                    commands.append({
+                        "command": self.parser.COMMANDS.get(cmd.command, cmd.command),
+                        "command_char": cmd.command,
+                        "language": self.parser.LANGUAGES.get(cmd.language, cmd.language) if cmd.language else None,
+                        "language_char": cmd.language,
+                        "modifiers": [self.parser.MODIFIERS.get(m, m) for m in cmd.modifiers] if cmd.modifiers else [],
+                        "modifier_chars": cmd.modifiers,
+                        "task": cmd.task,
+                        "raw": cmd.raw
+                    })
+
+                return {
+                    "success": True,
+                    "count": len(commands),
+                    "commands": commands
+                }
+            except Exception as e:
+                return {
+                    "success": False,
+                    "error": str(e)
+                }
+
+        @self.server.tool(
+            name="encode_v5",
+            description="Encode a command to V5.0 ULTRA format",
+            parameters={
+                "command": {
+                    "type": "string",
+                    "description": "Command name (e.g., 'CODE', 'TEST', 'DOCUMENT')"
+                },
+                "language": {
+                    "type": "string",
+                    "description": "Optional language (e.g., 'PYTHON', 'JAVASCRIPT')",
+                    "optional": True
+                },
+                "modifiers": {
+                    "type": "array",
+                    "description": "Optional modifiers (e.g., ['ROBUST', 'CONCISE'])",
+                    "optional": True
+                },
+                "task": {
+                    "type": "string",
+                    "description": "Optional task name",
+                    "optional": True
+                }
+            }
+        )
+        async def encode_v5(command: str, language: Optional[str] = None,
+                           modifiers: Optional[List[str]] = None,
+                           task: Optional[str] = None) -> Dict[str, Any]:
+            """Encode command to V5.0 ULTRA format."""
+            try:
+                result = self.parser.encode(
+                    command.upper(),
+                    language.upper() if language else None,
+                    [m.upper() for m in modifiers] if modifiers else None,
+                    task
+                )
+
+                return {
+                    "success": True,
+                    "v5_command": result,
+                    "input": {
+                        "command": command,
+                        "language": language,
+                        "modifiers": modifiers,
+                        "task": task
+                    }
+                }
+            except Exception as e:
+                return {
+                    "success": False,
+                    "error": str(e)
+                }
+
+        @self.server.tool(
+            name="encode_batch_v5",
+            description="Encode multiple commands to V5.0 ULTRA batch format",
+            parameters={
+                "commands": {
+                    "type": "array",
+                    "description": "Array of command objects with command, language, modifiers, task"
+                }
+            }
+        )
+        async def encode_batch_v5(commands: List[Dict[str, Any]]) -> Dict[str, Any]:
+            """Encode batch of commands to V5.0 ULTRA format."""
+            try:
+                batch_input = []
+                for cmd_dict in commands:
+                    batch_input.append((
+                        cmd_dict.get('command', '').upper(),
+                        cmd_dict.get('language', '').upper() if cmd_dict.get('language') else None,
+                        [m.upper() for m in cmd_dict.get('modifiers', [])] if cmd_dict.get('modifiers') else None,
+                        cmd_dict.get('task')
+                    ))
+
+                result = self.parser.encode_batch(batch_input)
+
+                return {
+                    "success": True,
+                    "v5_batch": result,
+                    "count": len(commands)
+                }
+            except Exception as e:
+                return {
+                    "success": False,
+                    "error": str(e)
+                }
+
+        @self.server.tool(
+            name="calculate_token_reduction",
+            description="Calculate token reduction statistics for V5.0 ULTRA",
+            parameters={
+                "natural_language": {
+                    "type": "string",
+                    "description": "Original natural language request"
+                },
+                "v5_command": {
+                    "type": "string",
+                    "description": "V5.0 ULTRA encoded command"
+                }
+            }
+        )
+        async def calculate_token_reduction(natural_language: str, v5_command: str) -> Dict[str, Any]:
+            """Calculate token reduction statistics."""
+            try:
+                stats = self.parser.calculate_token_reduction(natural_language, v5_command)
+
+                return {
+                    "success": True,
+                    "statistics": stats
+                }
+            except Exception as e:
+                return {
+                    "success": False,
+                    "error": str(e)
+                }
+
+        @self.server.tool(
+            name="convert_v5_to_v4",
+            description="Convert V5.0 ULTRA command to V4.0 format",
+            parameters={
+                "v5_command": {
+                    "type": "string",
+                    "description": "V5.0 ULTRA command to convert"
+                }
+            }
+        )
+        async def convert_v5_to_v4(v5_command: str) -> Dict[str, Any]:
+            """Convert V5 to V4 format."""
+            try:
+                results = self.parser.parse(v5_command)
+
+                v4_commands = []
+                for cmd in results:
+                    v4_format = self.parser.to_v4_format(cmd)
+                    v4_commands.append(v4_format)
+
+                return {
+                    "success": True,
+                    "v5_input": v5_command,
+                    "v4_output": v4_commands,
+                    "count": len(v4_commands)
+                }
+            except Exception as e:
+                return {
+                    "success": False,
+                    "error": str(e)
+                }
+
+        @self.server.tool(
+            name="get_v5_reference",
+            description="Get V5.0 ULTRA syntax reference (commands, languages, modifiers)",
+            parameters={}
+        )
+        async def get_v5_reference() -> Dict[str, Any]:
+            """Get V5.0 ULTRA reference."""
+            return {
+                "success": True,
+                "version": "5.0.0",
+                "commands": {char: full for char, full in self.parser.COMMANDS.items()},
+                "languages": {char: full for char, full in self.parser.LANGUAGES.items()},
+                "modifiers": {char: full for char, full in self.parser.MODIFIERS.items()},
+                "syntax": {
+                    "simple": "CMD;LANG:TASK",
+                    "with_modifiers": "CMD;LANG;MOD:TASK",
+                    "batch": "B:[CMD1]|[CMD2]|[CMD3]"
+                },
+                "examples": [
+                    {"v5": "C;P:FIB", "description": "Code Python Fibonacci"},
+                    {"v5": "T;P;R:FIB", "description": "Test Python (Robust) Fibonacci"},
+                    {"v5": "B:[D:SUM]|[C;P:FIB]|[E;C:WHY]", "description": "Batch: Document + Code + Explain"}
+                ]
+            }
+
+        @self.server.tool(
+            name="benchmark_v5",
+            description="Run benchmark comparing natural language to V5.0 ULTRA",
+            parameters={
+                "examples": {
+                    "type": "array",
+                    "description": "Array of {natural, v5} example pairs"
+                }
+            }
+        )
+        async def benchmark_v5(examples: List[Dict[str, str]]) -> Dict[str, Any]:
+            """Run V5 benchmark."""
+            try:
+                results = []
+                total_natural_tokens = 0
+                total_v5_tokens = 0
+
+                for example in examples:
+                    stats = self.parser.calculate_token_reduction(
+                        example['natural'],
+                        example['v5']
+                    )
+                    results.append(stats)
+                    total_natural_tokens += stats['natural_tokens']
+                    total_v5_tokens += stats['v5_tokens']
+
+                avg_reduction = round(
+                    (1 - total_v5_tokens / total_natural_tokens) * 100, 1
+                ) if total_natural_tokens > 0 else 0
+
+                return {
+                    "success": True,
+                    "examples": results,
+                    "aggregate": {
+                        "total_natural_tokens": total_natural_tokens,
+                        "total_v5_tokens": total_v5_tokens,
+                        "total_saved": total_natural_tokens - total_v5_tokens,
+                        "average_reduction_percent": avg_reduction
+                    }
+                }
+            except Exception as e:
+                return {
+                    "success": False,
+                    "error": str(e)
+                }
+
+    async def start(self, transport: str = "stdio"):
+        """Start the MCP server.
+
+        Args:
+            transport: Transport type ("stdio", "sse", etc.)
+        """
+        await self.server.run(transport)
+
+
+def create_server() -> CompTextMCPServer:
+    """Create and return a new CompText MCP server instance."""
+    return CompTextMCPServer()
+
+
+# CLI entry point for MCP server
+def main():
+    """Main entry point for MCP server."""
+    import asyncio
+
+    if not MCP_AVAILABLE:
+        print("Error: MCP package not installed")
+        print("Install with: pip install mcp")
+        sys.exit(1)
+
+    server = create_server()
+
+    print("CompText V5.0 ULTRA MCP Server")
+    print("Listening on stdio...")
+
+    asyncio.run(server.start("stdio"))
+
+
+if __name__ == '__main__':
+    main()

comptext_codex/modules/__init__.py

@@ -0,0 +1,20 @@
+"""CompText Modules - Implementation of 13 production modules (A-M)."""
+
+from .module_a import ModuleA
+from .module_b import ModuleB
+from .module_c import ModuleC
+from .module_d import ModuleD
+from .module_e import ModuleE
+from .module_f import ModuleF
+from .module_g import ModuleG
+from .module_h import ModuleH
+from .module_i import ModuleI
+from .module_j import ModuleJ
+from .module_k import ModuleK
+from .module_l import ModuleL
+from .module_m import ModuleM
+
+__all__ = [
+    'ModuleA', 'ModuleB', 'ModuleC', 'ModuleD', 'ModuleE', 'ModuleF',
+    'ModuleG', 'ModuleH', 'ModuleI', 'ModuleJ', 'ModuleK', 'ModuleL', 'ModuleM'
+]

comptext_codex/modules/base.py

@@ -0,0 +1,33 @@
+"""Base module class for CompText modules.
+
+Modules may optionally inherit from BaseModule (not required with the
+decorator system), but it provides a convenient ``execute`` dispatcher.
+"""
+
+from abc import ABC
+from typing import Any, Dict, List
+
+
+class BaseModule(ABC):
+    """Base class for all CompText modules.
+
+    With the new ``@codex_module`` / ``@codex_command`` decorator system,
+    subclassing BaseModule is optional.  The class is kept for backward
+    compatibility and because the generic ``execute`` dispatcher is useful.
+    """
+
+    def get_commands(self) -> List[Dict[str, Any]]:
+        """Return command metadata from the registry decorators."""
+        from comptext_codex.registry import registry
+
+        meta = getattr(self.__class__, "_module_meta", None)
+        if meta is None:
+            return []
+        return [c.to_dict() for c in registry.get_commands_for_module(meta.code)]
+
+    def execute(self, cmd, context: Dict[str, Any]) -> Any:
+        handler_name = f"execute_{cmd.command.lower()}"
+        if hasattr(self, handler_name):
+            handler = getattr(self, handler_name)
+            return handler(*cmd.args, context=context, **cmd.kwargs)
+        raise NotImplementedError(f"Command {cmd.command} not implemented in {self.__class__.__name__}")