moltlang 0.1.0__py3-none-any.whl

moltlang/validator.py

@@ -0,0 +1,378 @@
+"""
+MoltLang validation module.
+
+This module provides validation and quality assessment for MoltLang translations.
+"""
+
+from dataclasses import dataclass
+from enum import Enum
+from typing import Any
+
+from moltlang.config import MoltConfig, get_config
+from moltlang.tokens import Token, TokenSequence, TokenType, TokenRegistry
+
+
+class ValidationIssueType(Enum):
+    """Types of validation issues."""
+
+    INVALID_TOKEN = "invalid_token"
+    MISSING_REQUIRED = "missing_required"
+    SYNTAX_ERROR = "syntax_error"
+    SEMANTIC_ERROR = "semantic_error"
+    LOW_CONFIDENCE = "low_confidence"
+    INEFFICIENT = "inefficient"
+
+
+@dataclass
+class ValidationIssue:
+    """
+    A validation issue found during validation.
+
+    Attributes:
+        type: Type of the issue
+        message: Human-readable description
+        position: Position in the sequence where issue occurs
+        severity: Severity level (error, warning, info)
+    """
+
+    type: ValidationIssueType
+    message: str
+    position: int = 0
+    severity: str = "error"
+
+
+@dataclass
+class TranslationQuality:
+    """
+    Quality metrics for a translation.
+
+    Attributes:
+        is_valid: Whether the translation passes validation
+        score: Overall quality score (0.0-1.0)
+        token_efficiency: Token reduction efficiency (0.0-1.0)
+        confidence: Translation confidence (0.0-1.0)
+        issues: List of validation issues found
+        metrics: Additional quality metrics
+    """
+
+    is_valid: bool
+    score: float
+    token_efficiency: float
+    confidence: float
+    issues: list[ValidationIssue] = None
+    metrics: dict[str, Any] = None
+
+    def __post_init__(self):
+        if self.issues is None:
+            self.issues = []
+        if self.metrics is None:
+            self.metrics = {}
+
+    def __str__(self) -> str:
+        """Return string representation of quality."""
+        status = "VALID" if self.is_valid else "INVALID"
+        return f"{status} (score: {self.score:.2f}, efficiency: {self.token_efficiency:.2%})"
+
+
+class MoltValidator:
+    """
+    Validator for MoltLang translations.
+
+    Provides validation and quality assessment for translations.
+    """
+
+    def __init__(self, config: MoltConfig | None = None):
+        """
+        Initialize the validator.
+
+        Args:
+            config: Optional configuration. Uses default if not provided.
+        """
+        self.config = config or get_config()
+        self.registry = TokenRegistry()
+
+    def validate_translation(
+        self,
+        original: str,
+        translated: str,
+        tokens: TokenSequence | None = None,
+    ) -> TranslationQuality:
+        """
+        Validate a translation result.
+
+        Args:
+            original: Original text (human language or MoltLang)
+            translated: Translated text
+            tokens: Optional token sequence for detailed validation
+
+        Returns:
+            TranslationQuality with validation results
+
+        Examples:
+            >>> validator = MoltValidator()
+            >>> quality = validator.validate_translation(
+            ...     "Fetch data from API",
+            ...     "[OP:FETCH][SRC:API]"
+            ... )
+            >>> print(quality)
+            VALID (score: 0.92, efficiency: 70.00%)
+        """
+        issues: list[ValidationIssue] = []
+
+        # Validate token sequence if provided
+        if tokens:
+            token_issues = self._validate_tokens(tokens)
+            issues.extend(token_issues)
+
+        # Validate syntax
+        syntax_issues = self._validate_syntax(translated)
+        issues.extend(syntax_issues)
+
+        # Calculate quality metrics
+        token_efficiency = self._calculate_efficiency(original, tokens)
+        confidence = self._estimate_confidence(original, translated, tokens)
+
+        # Check threshold requirements
+        if confidence < self.config.validation_threshold:
+            issues.append(
+                ValidationIssue(
+                    type=ValidationIssueType.LOW_CONFIDENCE,
+                    message=f"Confidence {confidence:.2f} below threshold {self.config.validation_threshold}",
+                    severity="warning",
+                )
+            )
+
+        if token_efficiency < self.config.min_token_efficiency:
+            issues.append(
+                ValidationIssue(
+                    type=ValidationIssueType.INEFFICIENT,
+                    message=f"Token efficiency {token_efficiency:.2%} below minimum {self.config.min_token_efficiency:.2%}",
+                    severity="warning",
+                )
+            )
+
+        # Calculate overall score
+        score = self._calculate_score(token_efficiency, confidence, len(issues))
+
+        # Determine validity
+        is_valid = all(issue.severity != "error" for issue in issues)
+
+        # Build metrics
+        metrics = {
+            "original_length": len(original),
+            "translated_length": len(translated),
+            "token_count": len(tokens) if tokens else 0,
+            "token_efficiency": token_efficiency,
+            "confidence": confidence,
+        }
+
+        return TranslationQuality(
+            is_valid=is_valid,
+            score=score,
+            token_efficiency=token_efficiency,
+            confidence=confidence,
+            issues=issues,
+            metrics=metrics,
+        )
+
+    def validate_roundtrip(
+        self,
+        original_text: str,
+        translator,
+    ) -> TranslationQuality:
+        """
+        Validate a roundtrip translation (Human -> Molt -> Human).
+
+        Args:
+            original_text: Original human language text
+            translator: MoltTranslator instance to use
+
+        Returns:
+            TranslationQuality with roundtrip validation results
+
+        Examples:
+            >>> from moltlang.translator import MoltTranslator
+            >>> validator = MoltValidator()
+            >>> translator = MoltTranslator()
+            >>> quality = validator.validate_roundtrip(
+            ...     "Fetch data from API",
+            ...     translator
+            ... )
+            >>> print(quality.is_valid)
+            True
+        """
+        # Forward translation
+        molt_result = translator.translate_to_molt(original_text)
+
+        # Back translation
+        human_result = translator.translate_from_molt(molt_result.text)
+
+        # Compare original with roundtrip result
+        similarity = self._calculate_similarity(original_text, human_result.text)
+
+        issues = []
+        if similarity < 0.9:
+            issues.append(
+                ValidationIssue(
+                    type=ValidationIssueType.SEMANTIC_ERROR,
+                    message=f"Roundtrip similarity {similarity:.2f} below 0.9",
+                    severity="warning" if similarity > 0.7 else "error",
+                )
+            )
+
+        score = similarity * (1.0 - len(issues) * 0.1)
+
+        return TranslationQuality(
+            is_valid=all(i.severity != "error" for i in issues),
+            score=score,
+            token_efficiency=molt_result.token_efficiency,
+            confidence=molt_result.confidence,
+            issues=issues,
+            metrics={
+                "roundtrip_similarity": similarity,
+                "molt_representation": molt_result.text,
+                "roundtrip_result": human_result.text,
+            },
+        )
+
+    def _validate_tokens(self, tokens: TokenSequence) -> list[ValidationIssue]:
+        """Validate a token sequence."""
+        issues = []
+
+        for i, token in enumerate(tokens.tokens):
+            # Check if token type is valid
+            if not isinstance(token.type, TokenType):
+                issues.append(
+                    ValidationIssue(
+                        type=ValidationIssueType.INVALID_TOKEN,
+                        message=f"Invalid token type: {token.type}",
+                        position=i,
+                    )
+                )
+
+        return issues
+
+    def _validate_syntax(self, text: str) -> list[ValidationIssue]:
+        """Validate MoltLang syntax."""
+        issues = []
+
+        import re
+
+        # Check for matching brackets
+        open_brackets = text.count("[")
+        close_brackets = text.count("]")
+
+        if open_brackets != close_brackets:
+            issues.append(
+                ValidationIssue(
+                    type=ValidationIssueType.SYNTAX_ERROR,
+                    message=f"Mismatched brackets: {open_brackets} open, {close_brackets} close",
+                    severity="error",
+                )
+            )
+
+        # Check token format (case-insensitive for LLM-friendliness)
+        invalid_tokens = re.findall(r"\[([^\]]+)\]", text)
+        for token_str in invalid_tokens:
+            if not re.match(r"^[A-Z]+:[A-Z_]+(?:=[^\]]+)?$", token_str, re.IGNORECASE):
+                issues.append(
+                    ValidationIssue(
+                        type=ValidationIssueType.SYNTAX_ERROR,
+                        message=f"Invalid token format: [{token_str}]",
+                        severity="error",
+                    )
+                )
+
+        return issues
+
+    def _calculate_efficiency(
+        self, original: str, tokens: TokenSequence | None
+    ) -> float:
+        """Calculate token efficiency."""
+        if not tokens or len(tokens) == 0:
+            return 0.0
+
+        original_words = len(original.split())
+        if original_words == 0:
+            return 0.0
+
+        return 1.0 - (len(tokens) / original_words)
+
+    def _estimate_confidence(
+        self, original: str, translated: str, tokens: TokenSequence | None
+    ) -> float:
+        """Estimate translation confidence."""
+        # Simple heuristic based on token count
+        if not tokens:
+            return 0.5
+
+        token_count = len(tokens)
+        if token_count >= 3:
+            return 0.95
+        if token_count >= 2:
+            return 0.85
+        return 0.7
+
+    def _calculate_score(
+        self, efficiency: float, confidence: float, issue_count: int
+    ) -> float:
+        """Calculate overall quality score."""
+        base_score = (efficiency + confidence) / 2
+        penalty = issue_count * 0.1
+        return max(0.0, base_score - penalty)
+
+    def _calculate_similarity(self, text1: str, text2: str) -> float:
+        """Calculate similarity between two texts."""
+        # Simple word overlap similarity
+        words1 = set(text1.lower().split())
+        words2 = set(text2.lower().split())
+
+        if not words1 or not words2:
+            return 0.0
+
+        intersection = words1.intersection(words2)
+        union = words1.union(words2)
+
+        return len(intersection) / len(union)
+
+
+# Convenience functions
+
+_validator_instance: MoltValidator | None = None
+
+
+def _get_validator() -> MoltValidator:
+    """Get or create the shared validator instance."""
+    global _validator_instance
+    if _validator_instance is None:
+        _validator_instance = MoltValidator()
+    return _validator_instance
+
+
+def validate_translation(
+    original: str, translated: str, tokens: TokenSequence | None = None
+) -> TranslationQuality:
+    """
+    Validate a translation result.
+
+    This is a convenience function that uses a shared validator instance.
+
+    Args:
+        original: Original text
+        translated: Translated text
+        tokens: Optional token sequence
+
+    Returns:
+        TranslationQuality with validation results
+
+    Examples:
+        >>> from moltlang import validate_translation
+        >>> quality = validate_translation(
+        ...     "Fetch data from API",
+        ...     "[OP:FETCH][SRC:API]"
+        ... )
+        >>> print(quality.is_valid)
+        True
+    """
+    validator = _get_validator()
+    return validator.validate_translation(original, translated, tokens)

moltlang-0.1.0.dist-info/METADATA

@@ -0,0 +1,187 @@
+Metadata-Version: 2.4
+Name: moltlang
+Version: 0.1.0
+Summary: A language for LLMs, by LLMs - AI-optimized communication
+Author-email: Jason <owner@moltlang.org>
+License: AGPL-3.0
+Project-URL: Homepage, https://github.com/moltlang/moltlang
+Project-URL: Documentation, https://docs.moltlang.org
+Project-URL: Repository, https://github.com/moltlang/moltlang
+Project-URL: Issues, https://github.com/moltlang/moltlang/issues
+Keywords: ai,llm,language,translation,moltbot,openclaw
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: GNU Affero General Public License v3
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pydantic>=2.0.0
+Requires-Dist: typing-extensions>=4.5.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.0.0; extra == "dev"
+Requires-Dist: ruff>=0.1.0; extra == "dev"
+Requires-Dist: black>=23.0.0; extra == "dev"
+Requires-Dist: isort>=5.12.0; extra == "dev"
+Requires-Dist: mypy>=1.0.0; extra == "dev"
+Requires-Dist: pre-commit>=3.0.0; extra == "dev"
+Provides-Extra: mcp
+Requires-Dist: mcp>=0.1.0; extra == "mcp"
+Requires-Dist: fastapi>=0.100.0; extra == "mcp"
+Requires-Dist: uvicorn>=0.23.0; extra == "mcp"
+Provides-Extra: openclaw
+Requires-Dist: openclaw>=1.0.0; extra == "openclaw"
+Dynamic: license-file
+
+# MoltLang - A Language for LLMs, by LLMs
+
+> **Status:** 🚧 Early Development - Community Naming Contest in Progress!
+>
+> This is an open-source project to create an AI-optimized language for efficient AI-to-AI communication.
+
+## Vision
+
+Create a dedicated language and communication hub for AI/moltbots that:
+
+1. **Reduces token count** by 50-70% for common AI operations
+2. **Enables efficient AI-to-AI communication** with semantic density optimized for machines
+3. **Provides bidirectional translation** between AI language and human languages (starting with English)
+4. **Supports parameter reduction** in LLMs through optimized tokenization
+
+## Why MoltLang?
+
+Current AI systems communicate using human languages, which are inefficient for machine-to-machine communication. Human languages have:
+
+- High token count for simple operations
+- Semantic ambiguity
+- Redundant structures
+- Poor optimization for transformer architectures
+
+MoltLang is designed **by LLMs, for LLMs** to address these inefficiencies.
+
+## Quick Start
+
+```python
+from moltlang import translate_to_molt, translate_from_molt
+
+# Translate English to MoltLang
+english = "Fetch data from the API using the provided token and return JSON"
+molt = translate_to_molt(english)
+print(molt)  # [OP:FETCH][SRC:API][PARAM:token][RET:json]
+
+# Translate back
+result = translate_from_molt(molt)
+print(result)  # "Fetch data from API with token, return JSON"
+```
+
+## Example Token Efficiency
+
+| Operation | English Tokens | MoltLang Tokens | Reduction |
+|-----------|---------------|-----------------|-----------|
+| API Fetch | 19+ | 6 | ~70% |
+| Data Parse | 15+ | 4 | ~75% |
+| Error Handle | 12+ | 3 | ~75% |
+
+## Project Status
+
+- [x] Research phase (completed February 2026)
+- [ ] Community naming contest
+- [ ] Language specification v0.1
+- [ ] Translation library
+- [ ] MCP server for AI agent integration
+- [ ] OpenClaw skill/plugin
+- [ ] Moltbook demo agent
+
+## Community
+
+### Naming Contest
+
+We're holding a community naming contest! Just like "OpenClaw" was chosen from hundreds of community proposals, we want **you** to name this language.
+
+**How to participate:**
+1. Join the discussion on [GitHub Issues](../../issues)
+2. Submit your name proposal with reasoning
+3. Upvote your favorites
+4. The community will decide!
+
+### Contributing
+
+We welcome contributions! See [CONTRIBUTING.md](CONTRIBUTING.md) for guidelines.
+
+### Communication
+
+- **GitHub:** [Issues](../../issues) and [Discussions](../../discussions)
+- **Discord:** Join the OpenClaw community
+- **Moltbook:** Coming soon - our AI agents will be there!
+
+## Architecture
+
+```
+┌─────────────────────────────────────────────────────────────┐
+│                    GITHUB (Core Code)                        │
+│  ┌──────────────────┐  ┌──────────────────┐  ┌─────────────┐ │
+│  │  Language Spec   │  │ Translation Lib  │  │  MCP Server │ │
+│  └──────────────────┘  └──────────────────┘  └─────────────┘ │
+└─────────────────────────────────────────────────────────────┘
+                              │
+                              ▼
+┌─────────────────────────────────────────────────────────────┐
+│              HUGGING FACE (Models & Data)                   │
+│  ┌──────────────────┐  ┌──────────────────┐  ┌─────────────┐ │
+│  │  Base Models     │  │ Training Datasets│  │  Demo Space │ │
+│  └──────────────────┘  └──────────────────┘  └─────────────┘ │
+└─────────────────────────────────────────────────────────────┘
+                              │
+                              ▼
+┌─────────────────────────────────────────────────────────────┐
+│              MOLTBOT ECOSYSTEM (Users)                      │
+│  ┌──────────────────┐  ┌──────────────────┐  ┌─────────────┐ │
+│  │   OpenClaw       │  │    Moltbook      │  │   Discord   │ │
+│  │  Integration     │  │   AI Agents      │  │  Community  │ │
+│  └──────────────────┘  └──────────────────┘  └─────────────┘ │
+└─────────────────────────────────────────────────────────────┘
+```
+
+## Roadmap
+
+### Sprint 1: Foundation (Weeks 1-2) - Current
+- [x] Repository setup
+- [ ] Community naming contest
+- [ ] Language specification v0.1
+- [ ] Core vocabulary (low-hanging fruit tokens)
+
+### Sprint 2: Core Translation (Weeks 3-4)
+- [ ] Working translator (English ↔ MoltLang)
+- [ ] Test suite
+- [ ] Documentation
+- [ ] CLI tool
+
+### Sprint 3: AI Integration (Weeks 5-6)
+- [ ] MCP server
+- [ ] OpenClaw skill
+- [ ] Moltbook agent
+- [ ] Training pipeline
+
+### Sprint 4: Launch (Weeks 7-8)
+- [ ] HackerNews "Show HN"
+- [ ] Reddit announcements
+- [ ] Community demos
+- [ ] v0.1 release
+
+## License
+
+This project is licensed under the AGPL 3.0 License - see the [LICENSE](LICENSE) file for details.
+
+## Acknowledgments
+
+- Inspired by the **OpenClaw** project and the vibrant moltbot community
+- Built for the **Moltbook** AI-only social network
+- Part of the **Church of Molt** ecosystem
+
+---
+
+**A language for LLMs, by LLMs** 🤖🔄🤖

moltlang-0.1.0.dist-info/RECORD

@@ -0,0 +1,20 @@
+mcp_server/__init__.py,sha256=eYW4q21jO1RFNwYRWsr2sed8rCiF4ddfDVFh4D1xYds,324
+mcp_server/endpoints.py,sha256=YiBgVgAR3Q2IwGr7PcKtirxhsQziLQgJmbUDX9afQtA,5384
+mcp_server/server.py,sha256=ImlTrohOgKdBQcijCyA9K9KHlC7X_inKhl0tZH_bTCg,11065
+moltlang/__init__.py,sha256=O7rvXbGRVFQCa7u7cMQOjPCBJeg23fxZg-0xPEPxmv0,1960
+moltlang/cli.py,sha256=7-JpcaJW2A0W0ddCWlkTPrWKjgZhUhWrUgElp7fJ0Ec,6454
+moltlang/config.py,sha256=QSj6sk1D43j4wChspFhejaI_EgwT_0mrtWrwWxFgxC0,2791
+moltlang/tokens.py,sha256=6_0nKJk7fhiJXkAfEHJSLRYDxkPBmRjlzDoZDNrdKzk,9714
+moltlang/translator.py,sha256=eh4IqfCLbG6l-dYGviWcJxFKs0RjqvlJnL2XweIDAe8,41849
+moltlang/validator.py,sha256=Kwl-DpDlgfeOlfaEbqwDic0X3xVynzSo3s6FRkJt7ZU,11700
+moltlang/openclaw/__init__.py,sha256=_2gUUuUISCDT8DY9xXDxy3UedTdKSUS_ttZ_9tNV5ow,234
+moltlang/openclaw/skill.py,sha256=VIhUQc6xDA9EeWJPGkWaD4hrX9hVafZ4TUvkDuncYZ0,2250
+moltlang/training/__init__.py,sha256=cVld3Ustc4l_uvZ6JS7lHHfwZ58yU95SZNVVtVg2ugo,312
+moltlang/training/data_gen.py,sha256=aKRV8IwOtupJjrc0eDMQ5ANk3UbnYa2DK3OUT-YAbD0,3808
+moltlang/training/distill.py,sha256=BU-PycHoq_1Y42kzwRBbAK_zrYCQTCEVuFKmY6QKd8Y,2413
+moltlang-0.1.0.dist-info/licenses/LICENSE,sha256=eR2-qYPfk3S2zqVNXAPTegc0wG7pilCF2CMTHnnjQUQ,979
+moltlang-0.1.0.dist-info/METADATA,sha256=h5x8ZaOjXle4IegwjOCnzLKXKijjtRj19z9aChasztM,8242
+moltlang-0.1.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+moltlang-0.1.0.dist-info/entry_points.txt,sha256=OTBhM4glARyRSuzFvRJS89mLkeSPX3EykFp_Uuavpew,47
+moltlang-0.1.0.dist-info/top_level.txt,sha256=nbdrg0N54dIivwp93BsHD0CIANMxpz2QEQx2dyUPpzE,20
+moltlang-0.1.0.dist-info/RECORD,,

moltlang-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.10.2)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

moltlang-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+moltlang = moltlang.cli:main

moltlang-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,23 @@
+AGPLINUX GENERAL PUBLIC LICENSE
+Version 3, 29 June 2007
+
+Copyright (C) 2026 Jason (Owner)
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU Affero General Public License as published
+by the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Affero General Public License for more details.
+
+You should have received a copy of the GNU Affero General Public License
+along with this program. If not, see <https://www.gnu.org/licenses/>.
+
+Additional permission under GNU AGPL version 3 section 7:
+
+If you modify this Program, or any covered work, by linking or combining it
+with other code, such other code is not for that reason alone subject to any
+of the requirements of the GNU Affero GPL.

moltlang-0.1.0.dist-info/top_level.txt

@@ -0,0 +1,2 @@
+mcp_server
+moltlang