moltlang 0.1.0__py3-none-any.whl

moltlang/cli.py

@@ -0,0 +1,247 @@
+"""
+MoltLang Command Line Interface.
+
+This module provides a CLI for interacting with MoltLang translation.
+"""
+
+import argparse
+import sys
+from typing import Any
+
+from moltlang import (
+    translate_to_molt,
+    translate_from_molt,
+    validate_translation,
+    MoltTranslator,
+    MoltValidator,
+)
+from moltlang.config import get_config
+from moltlang.tokens import TokenType, TokenRegistry
+
+
+def cmd_translate(args: argparse.Namespace) -> int:
+    """Handle translate command."""
+    translator = MoltTranslator()
+
+    if args.to_molt:
+        result = translator.translate_to_molt(args.text)
+        print(result.text)
+        if args.verbose:
+            print(f"\nTokens: {result.token_count}")
+            print(f"Original: {result.original_token_count}")
+            print(f"Efficiency: {result.token_efficiency:.2%}")
+            print(f"Confidence: {result.confidence:.2f}")
+    else:
+        result = translator.translate_from_molt(args.text)
+        print(result.text)
+        if args.verbose:
+            print(f"\nTokens: {result.token_count}")
+            print(f"Confidence: {result.confidence:.2f}")
+
+    return 0
+
+
+def cmd_validate(args: argparse.Namespace) -> int:
+    """Handle validate command."""
+    quality = validate_translation(args.original, args.translated)
+
+    print(f"Valid: {quality.is_valid}")
+    print(f"Score: {quality.score:.2f}")
+    print(f"Token Efficiency: {quality.token_efficiency:.2%}")
+    print(f"Confidence: {quality.confidence:.2f}")
+
+    if quality.issues:
+        print(f"\nIssues ({len(quality.issues)}):")
+        for issue in quality.issues:
+            print(f"  [{issue.severity}] {issue.type.value}: {issue.message}")
+
+    return 0 if quality.is_valid else 1
+
+
+def cmd_tokens(args: argparse.Namespace) -> int:
+    """Handle tokens command."""
+    registry = TokenRegistry()
+
+    if args.type:
+        token_type_prefix = args.type.upper()
+        tokens = [t for t in TokenType if t.name.startswith(token_type_prefix)]
+    else:
+        tokens = list(TokenType)
+
+    print(f"Available tokens ({len(tokens)}):")
+    for token in tokens:
+        print(f"  {token.name:30} {token.value}")
+
+    return 0
+
+
+def cmd_roundtrip(args: argparse.Namespace) -> int:
+    """Handle roundtrip command."""
+    translator = MoltTranslator()
+    validator = MoltValidator()
+
+    # Forward translation
+    molt_result = translator.translate_to_molt(args.text)
+    print(f"Original: {args.text}")
+    print(f"MoltLang: {molt_result.text}")
+
+    # Back translation
+    human_result = translator.translate_from_molt(molt_result.text)
+    print(f"Roundtrip: {human_result.text}")
+
+    # Validate roundtrip
+    quality = validator.validate_roundtrip(args.text, translator)
+    print(f"\nRoundtrip Quality:")
+    print(f"  Valid: {quality.is_valid}")
+    print(f"  Similarity: {quality.metrics.get('roundtrip_similarity', 0):.2f}")
+
+    return 0
+
+
+def cmd_demo(args: argparse.Namespace) -> int:
+    """Handle demo command."""
+    print("=" * 50)
+    print("MoltLang Demo")
+    print("=" * 50)
+
+    examples = [
+        "Fetch data from API and return JSON",
+        "Parse data from file",
+        "Search database for user",
+        "Transform and validate input",
+    ]
+
+    translator = MoltTranslator()
+
+    for example in examples:
+        result = translator.translate_to_molt(example)
+        print(f"\nEnglish: {example}")
+        print(f"MoltLang: {result.text}")
+        print(f"Efficiency: {result.token_efficiency:.2%}")
+
+    print("\n" + "=" * 50)
+    return 0
+
+
+def main() -> int:
+    """
+    Main CLI entry point.
+
+    Returns:
+        Exit code (0 for success, non-zero for error)
+    """
+    parser = argparse.ArgumentParser(
+        description="MoltLang - A Language for LLMs, by LLMs",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  moltlang translate "Fetch data from API" --to-molt
+  moltlang translate "[OP:FETCH][SRC:API]" --from-molt
+  moltlang validate "Fetch data" "[OP:FETCH][SRC:API]"
+  moltlang tokens --type OP
+  moltlang roundtrip "Parse data from database"
+  moltlang demo
+        """,
+    )
+
+    parser.add_argument(
+        "--version", action="version", version="MoltLang 0.1.0"
+    )
+
+    subparsers = parser.add_subparsers(
+        dest="command",
+        title="Commands",
+        description="Available commands",
+    )
+
+    # Translate command
+    translate_parser = subparsers.add_parser(
+        "translate",
+        help="Translate between human language and MoltLang",
+    )
+    translate_parser.add_argument(
+        "text",
+        help="Text to translate",
+    )
+    translate_parser.add_argument(
+        "--to-molt",
+        action="store_true",
+        help="Translate to MoltLang (default: from MoltLang)",
+    )
+    translate_parser.add_argument(
+        "--from-molt",
+        action="store_true",
+        help="Translate from MoltLang (default: to MoltLang)",
+    )
+    translate_parser.add_argument(
+        "-v", "--verbose",
+        action="store_true",
+        help="Show detailed output",
+    )
+
+    # Validate command
+    validate_parser = subparsers.add_parser(
+        "validate",
+        help="Validate a translation",
+    )
+    validate_parser.add_argument(
+        "original",
+        help="Original text",
+    )
+    validate_parser.add_argument(
+        "translated",
+        help="Translated text",
+    )
+
+    # Tokens command
+    tokens_parser = subparsers.add_parser(
+        "tokens",
+        help="List available tokens",
+    )
+    tokens_parser.add_argument(
+        "--type",
+        help="Filter by token type (e.g., OP, SRC, RET)",
+    )
+
+    # Roundtrip command
+    roundtrip_parser = subparsers.add_parser(
+        "roundtrip",
+        help="Test roundtrip translation",
+    )
+    roundtrip_parser.add_argument(
+        "text",
+        help="Text to translate",
+    )
+
+    # Demo command
+    subparsers.add_parser(
+        "demo",
+        help="Run interactive demo",
+    )
+
+    # Parse arguments
+    args = parser.parse_args()
+
+    # Handle no command
+    if args.command is None:
+        parser.print_help()
+        return 0
+
+    # Dispatch to command handler
+    handlers = {
+        "translate": cmd_translate,
+        "validate": cmd_validate,
+        "tokens": cmd_tokens,
+        "roundtrip": cmd_roundtrip,
+        "demo": cmd_demo,
+    }
+
+    handler = handlers.get(args.command)
+    if handler:
+        return handler(args)
+
+    return 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())

moltlang/config.py

@@ -0,0 +1,86 @@
+"""
+MoltLang configuration module.
+
+This module handles configuration for the MoltLang translation system,
+including token sets, optimization settings, and language preferences.
+"""
+
+from dataclasses import dataclass, field
+from enum import Enum
+from typing import Any
+
+
+class OptimizationLevel(Enum):
+    """Translation optimization levels."""
+
+    FAST = "fast"  # Fast translation, lower accuracy
+    BALANCED = "balanced"  # Balance between speed and accuracy
+    ACCURATE = "accurate"  # Highest accuracy, slower
+
+
+@dataclass
+class MoltConfig:
+    """
+    Configuration for MoltLang translation.
+
+    Attributes:
+        max_tokens: Maximum tokens to generate in translation
+        temperature: Sampling temperature for translation (0.0-1.0)
+        optimization_level: Speed/accuracy tradeoff
+        enable_cache: Enable translation caching
+        target_token_reduction: Target token reduction percentage (0-100)
+        strict_mode: Enable strict validation of MoltLang syntax
+        human_language: Target human language for translation (default: English)
+    """
+
+    max_tokens: int = 4096
+    temperature: float = 0.3
+    optimization_level: OptimizationLevel = OptimizationLevel.BALANCED
+    enable_cache: bool = True
+    target_token_reduction: float = 0.6  # Target 60% token reduction
+    strict_mode: bool = False
+    human_language: str = "en"
+    custom_token_registry: dict[str, Any] = field(default_factory=dict)
+
+    # Token efficiency settings
+    min_token_efficiency: float = 0.5  # Minimum 50% token efficiency
+    prefer_high_density: bool = True
+
+    # Validation settings
+    validation_threshold: float = 0.95  # 95% translation accuracy threshold
+    enable_roundtrip_validation: bool = True
+
+    def __post_init__(self):
+        """Validate configuration after initialization."""
+        if not 0.0 <= self.temperature <= 1.0:
+            raise ValueError("temperature must be between 0.0 and 1.0")
+        if not 0.0 <= self.target_token_reduction <= 1.0:
+            raise ValueError("target_token_reduction must be between 0.0 and 1.0")
+        if not 0.0 <= self.min_token_efficiency <= 1.0:
+            raise ValueError("min_token_efficiency must be between 0.0 and 1.0")
+
+
+# Default configuration instance
+DEFAULT_CONFIG = MoltConfig()
+
+
+def get_config(**kwargs) -> MoltConfig:
+    """
+    Get a MoltConfig instance with optional overrides.
+
+    Args:
+        **kwargs: Configuration overrides
+
+    Returns:
+        MoltConfig instance with overrides applied
+
+    Examples:
+        >>> config = get_config(temperature=0.5, strict_mode=True)
+        >>> config.temperature
+        0.5
+    """
+    config = DEFAULT_CONFIG
+    for key, value in kwargs.items():
+        if hasattr(config, key):
+            setattr(config, key, value)
+    return config

moltlang/openclaw/__init__.py

@@ -0,0 +1,11 @@
+"""
+MoltLang OpenClaw Integration.
+
+This module provides integration with OpenClaw for AI agent communication.
+"""
+
+__version__ = "0.1.0"
+
+from moltlang.openclaw.skill import MoltLangOpenClawSkill
+
+__all__ = ["MoltLangOpenClawSkill"]

moltlang/openclaw/skill.py

@@ -0,0 +1,77 @@
+"""
+MoltLang OpenClaw Skill.
+
+This module implements the OpenClaw skill for MoltLang translation.
+"""
+
+from typing import Any
+
+from moltlang import translate_to_molt, translate_from_molt, MoltTranslator
+
+
+class MoltLangOpenClawSkill:
+    """
+    OpenClaw skill for MoltLang translation.
+
+    Enables OpenClaw agents to use MoltLang for efficient communication.
+    """
+
+    def __init__(self):
+        """Initialize the skill."""
+        self.name = "moltlang"
+        self.version = "0.1.0"
+        self.description = "Translate between human language and MoltLang"
+        self.translator = MoltTranslator()
+
+    async def handle_message(self, message: str, context: dict[str, Any]) -> str:
+        """
+        Handle incoming messages and translate to MoltLang.
+
+        Args:
+            message: Human language message
+            context: OpenClaw context
+
+        Returns:
+            MoltLang translation
+        """
+        return self.translator.translate_to_molt(message).text
+
+    async def handle_molt_message(self, molt: str, context: dict[str, Any]) -> str:
+        """
+        Handle MoltLang messages and translate to human language.
+
+        Args:
+            molt: MoltLang message
+            context: OpenClaw context
+
+        Returns:
+            Human language translation
+        """
+        return self.translator.translate_from_molt(molt).text
+
+    def get_commands(self) -> list[dict[str, Any]]:
+        """Return available commands for OpenClaw."""
+        return [
+            {
+                "name": "molt",
+                "description": "Translate text to MoltLang",
+                "parameters": {
+                    "text": {
+                        "type": "string",
+                        "description": "Text to translate",
+                        "required": True,
+                    }
+                },
+            },
+            {
+                "name": "unmolt",
+                "description": "Translate MoltLang to human language",
+                "parameters": {
+                    "molt": {
+                        "type": "string",
+                        "description": "MoltLang text",
+                        "required": True,
+                    }
+                },
+            },
+        ]