tzero-mcp 10.7.0 → 10.7.2

package/src/tzero_bridge.py

@@ -0,0 +1,362 @@
+# -*- coding: utf-8 -*-
+"""
+Siber Akademi — T-Zero Universal Polyglot Type & Schema Transpiler.
+Developer: Toprak Ahmet Aydoğmuş (Siber Akademi)
+License: MIT
+
+Transpiles Python @dataclass and Pydantic data models into TypeScript interfaces,
+Rust structs, and Go structs deterministically via AST.
+"""
+
+import os
+import sys
+import ast
+from dataclasses import dataclass, field
+from typing import Dict, List, Any, Optional, Tuple
+
+
+@dataclass
+class ModelField:
+    name: str
+    py_type: str
+    is_optional: bool = False
+    doc: str = ""
+
+
+@dataclass
+class TranspiledModel:
+    class_name: str
+    fields: List[ModelField] = field(default_factory=list)
+    docstring: str = ""
+    typescript: str = ""
+    rust: str = ""
+    golang: str = ""
+    kotlin: str = ""
+    swift: str = ""
+
+
+class PolyglotTypeBridge:
+    """Deterministic Polyglot Type & Schema Transpiler."""
+
+    # Type Mapping Tables
+    TYPE_MAP_TS = {
+        "str": "string",
+        "int": "number",
+        "float": "number",
+        "bool": "boolean",
+        "bytes": "Uint8Array",
+        "dict": "Record<string, any>",
+        "list": "any[]",
+        "set": "Set<any>",
+        "tuple": "[any]",
+        "Any": "any",
+        "datetime": "string",
+        "date": "string",
+        "UUID": "string",
+    }
+
+    TYPE_MAP_RUST = {
+        "str": "String",
+        "int": "i64",
+        "float": "f64",
+        "bool": "bool",
+        "bytes": "Vec<u8>",
+        "dict": "std::collections::HashMap<String, serde_json::Value>",
+        "list": "Vec<serde_json::Value>",
+        "set": "std::collections::HashSet<String>",
+        "Any": "serde_json::Value",
+        "datetime": "chrono::DateTime<chrono::Utc>",
+        "date": "chrono::NaiveDate",
+        "UUID": "uuid::Uuid",
+    }
+
+    TYPE_MAP_GO = {
+        "str": "string",
+        "int": "int64",
+        "float": "float64",
+        "bool": "bool",
+        "bytes": "[]byte",
+        "dict": "map[string]interface{}",
+        "list": "[]interface{}",
+        "set": "[]string",
+        "Any": "interface{}",
+        "datetime": "time.Time",
+        "date": "time.Time",
+        "UUID": "string",
+    }
+
+    TYPE_MAP_KOTLIN = {
+        "str": "String",
+        "int": "Long",
+        "float": "Double",
+        "bool": "Boolean",
+        "bytes": "ByteArray",
+        "dict": "Map<String, Any>",
+        "list": "List<Any>",
+        "set": "Set<String>",
+        "Any": "Any",
+        "datetime": "java.time.Instant",
+        "date": "java.time.LocalDate",
+        "UUID": "java.util.UUID",
+    }
+
+    TYPE_MAP_SWIFT = {
+        "str": "String",
+        "int": "Int",
+        "float": "Double",
+        "bool": "Bool",
+        "bytes": "Data",
+        "dict": "[String: Any]",
+        "list": "[Any]",
+        "set": "Set<String>",
+        "Any": "Any",
+        "datetime": "Date",
+        "date": "Date",
+        "UUID": "UUID",
+    }
+
+    @classmethod
+    def _parse_py_type(cls, node: ast.AST) -> Tuple[str, bool]:
+        """Returns (base_type_str, is_optional)."""
+        if node is None:
+            return "Any", False
+
+        # e.g. Optional[T] or Union[T, None]
+        if isinstance(node, ast.Subscript):
+            val_name = getattr(node.value, "id", "")
+            if val_name == "Optional":
+                inner, _ = cls._parse_py_type(node.slice)
+                return inner, True
+            elif val_name in ("List", "list"):
+                inner, _ = cls._parse_py_type(node.slice)
+                return f"List[{inner}]", False
+            elif val_name in ("Dict", "dict"):
+                if isinstance(node.slice, ast.Tuple) and len(node.slice.elts) == 2:
+                    k, _ = cls._parse_py_type(node.slice.elts[0])
+                    v, _ = cls._parse_py_type(node.slice.elts[1])
+                    return f"Dict[{k}, {v}]", False
+                return "Dict[str, Any]", False
+            elif val_name == "Union":
+                # Check if None is in union
+                elts = node.slice.elts if isinstance(node.slice, ast.Tuple) else [node.slice]
+                non_none = [e for e in elts if not (isinstance(e, ast.Constant) and e.value is None) and getattr(e, "id", "") != "None"]
+                if len(non_none) == 1:
+                    inner, _ = cls._parse_py_type(non_none[0])
+                    return inner, True
+                return "Any", True
+            return "Any", False
+        elif isinstance(node, ast.Name):
+            return node.id, False
+        elif isinstance(node, ast.Constant):
+            return str(node.value), False
+
+        return "Any", False
+
+    @classmethod
+    def _to_ts_type(cls, py_type: str, is_optional: bool) -> str:
+        if py_type.startswith("List["):
+            inner = py_type[5:-1]
+            ts_inner = cls._to_ts_type(inner, False)
+            res = f"{ts_inner}[]"
+        elif py_type.startswith("Dict["):
+            parts = py_type[5:-1].split(",", 1)
+            k = cls._to_ts_type(parts[0].strip(), False) if len(parts) > 0 else "string"
+            v = cls._to_ts_type(parts[1].strip(), False) if len(parts) > 1 else "any"
+            res = f"Record<{k}, {v}>"
+        else:
+            res = cls.TYPE_MAP_TS.get(py_type, py_type)
+
+        return f"{res} | null" if is_optional else res
+
+    @classmethod
+    def _to_rust_type(cls, py_type: str, is_optional: bool) -> str:
+        if py_type.startswith("List["):
+            inner = py_type[5:-1]
+            rust_inner = cls._to_rust_type(inner, False)
+            res = f"Vec<{rust_inner}>"
+        elif py_type.startswith("Dict["):
+            parts = py_type[5:-1].split(",", 1)
+            k = cls._to_rust_type(parts[0].strip(), False) if len(parts) > 0 else "String"
+            v = cls._to_rust_type(parts[1].strip(), False) if len(parts) > 1 else "serde_json::Value"
+            res = f"std::collections::HashMap<{k}, {v}>"
+        else:
+            res = cls.TYPE_MAP_RUST.get(py_type, py_type)
+
+        return f"Option<{res}>" if is_optional else res
+
+    @classmethod
+    def _to_go_type(cls, py_type: str, is_optional: bool) -> str:
+        if py_type.startswith("List["):
+            inner = py_type[5:-1]
+            go_inner = cls._to_go_type(inner, False)
+            res = f"[]{go_inner}"
+        elif py_type.startswith("Dict["):
+            parts = py_type[5:-1].split(",", 1)
+            k = cls._to_go_type(parts[0].strip(), False) if len(parts) > 0 else "string"
+            v = cls._to_go_type(parts[1].strip(), False) if len(parts) > 1 else "interface{}"
+            res = f"map[{k}]{v}"
+        else:
+            res = cls.TYPE_MAP_GO.get(py_type, py_type)
+
+        return f"*{res}" if is_optional else res
+
+    @classmethod
+    def _to_kotlin_type(cls, py_type: str, is_optional: bool) -> str:
+        if py_type.startswith("List["):
+            inner = py_type[5:-1]
+            kt_inner = cls._to_kotlin_type(inner, False)
+            res = f"List<{kt_inner}>"
+        elif py_type.startswith("Dict["):
+            parts = py_type[5:-1].split(",", 1)
+            k = cls._to_kotlin_type(parts[0].strip(), False) if len(parts) > 0 else "String"
+            v = cls._to_kotlin_type(parts[1].strip(), False) if len(parts) > 1 else "Any"
+            res = f"Map<{k}, {v}>"
+        else:
+            res = cls.TYPE_MAP_KOTLIN.get(py_type, py_type)
+
+        return f"{res}?" if is_optional else res
+
+    @classmethod
+    def _to_swift_type(cls, py_type: str, is_optional: bool) -> str:
+        if py_type.startswith("List["):
+            inner = py_type[5:-1]
+            swift_inner = cls._to_swift_type(inner, False)
+            res = f"[{swift_inner}]"
+        elif py_type.startswith("Dict["):
+            parts = py_type[5:-1].split(",", 1)
+            k = cls._to_swift_type(parts[0].strip(), False) if len(parts) > 0 else "String"
+            v = cls._to_swift_type(parts[1].strip(), False) if len(parts) > 1 else "Any"
+            res = f"[{k}: {v}]"
+        else:
+            res = cls.TYPE_MAP_SWIFT.get(py_type, py_type)
+
+        return f"{res}?" if is_optional else res
+
+    @classmethod
+    def parse_python_models(cls, py_code: str) -> List[TranspiledModel]:
+        """Parses Python classes and generates TypeScript, Rust, and Go interfaces."""
+        try:
+            tree = ast.parse(py_code)
+        except Exception:
+            return []
+
+        models: List[TranspiledModel] = []
+
+        for node in tree.body:
+            if isinstance(node, ast.ClassDef):
+                fields: List[ModelField] = []
+                doc = ast.get_docstring(node) or ""
+
+                for item in node.body:
+                    if isinstance(item, ast.AnnAssign) and isinstance(item.target, ast.Name):
+                        fname = item.target.id
+                        ptype, opt = cls._parse_py_type(item.annotation)
+                        fields.append(ModelField(name=fname, py_type=ptype, is_optional=opt))
+
+                if not fields:
+                    continue
+
+                # Generate TS
+                ts_lines = [f"export interface {node.name} {{"]
+                for f in fields:
+                    opt_mark = "?" if f.is_optional else ""
+                    ts_t = cls._to_ts_type(f.py_type, f.is_optional)
+                    ts_lines.append(f"  {f.name}{opt_mark}: {ts_t};")
+                ts_lines.append("}")
+                ts_str = "\n".join(ts_lines)
+
+                # Generate Rust
+                rust_lines = [
+                    "#[derive(Debug, Clone, Serialize, Deserialize)]",
+                    f"pub struct {node.name} {{"
+                ]
+                for f in fields:
+                    r_type = cls._to_rust_type(f.py_type, f.is_optional)
+                    rust_lines.append(f"    pub {f.name}: {r_type},")
+                rust_lines.append("}")
+                rust_str = "\n".join(rust_lines)
+
+                # Generate Go
+                go_lines = [f"type {node.name} struct {{"]
+                for f in fields:
+                    g_type = cls._to_go_type(f.py_type, f.is_optional)
+                    pascal_name = "".join(p.capitalize() for p in f.name.split("_"))
+                    go_lines.append(f'\t{pascal_name} {g_type} `json:"{f.name}"`')
+                go_lines.append("}")
+                go_str = "\n".join(go_lines)
+
+                # Generate Kotlin
+                kt_lines = [f"data class {node.name}("]
+                for idx, f in enumerate(fields):
+                    kt_type = cls._to_kotlin_type(f.py_type, f.is_optional)
+                    parts = f.name.split("_")
+                    camel_name = parts[0] + "".join(p.capitalize() for p in parts[1:]) if len(parts) > 1 else f.name
+                    default_suffix = " = null" if f.is_optional else ""
+                    comma = "," if idx < len(fields) - 1 else ""
+                    kt_lines.append(f"    val {camel_name}: {kt_type}{default_suffix}{comma}")
+                kt_lines.append(")")
+                kt_str = "\n".join(kt_lines)
+
+                # Generate Swift
+                swift_lines = [
+                    f"public struct {node.name}: Codable, Equatable {{",
+                ]
+                for f in fields:
+                    swift_type = cls._to_swift_type(f.py_type, f.is_optional)
+                    parts = f.name.split("_")
+                    camel_name = parts[0] + "".join(p.capitalize() for p in parts[1:]) if len(parts) > 1 else f.name
+                    swift_lines.append(f"    public let {camel_name}: {swift_type}")
+                swift_lines.append("}")
+                swift_str = "\n".join(swift_lines)
+
+                models.append(TranspiledModel(
+                    class_name=node.name,
+                    fields=fields,
+                    docstring=doc,
+                    typescript=ts_str,
+                    rust=rust_str,
+                    golang=go_str,
+                    kotlin=kt_str,
+                    swift=swift_str
+                ))
+
+        return models
+
+    @classmethod
+    def transpile_file(cls, py_file_path: str, target_lang: str = "ts") -> str:
+        """Reads Python file and returns transpiled definitions in requested language."""
+        with open(py_file_path, "r", encoding="utf-8", errors="replace") as f:
+            code = f.read()
+
+        models = cls.parse_python_models(code)
+        if not models:
+            return f"// No typed models or dataclasses detected in {os.path.basename(py_file_path)}"
+
+        target = target_lang.lower().strip()
+        if target in ("ts", "typescript"):
+            return "\n\n".join(m.typescript for m in models)
+        elif target in ("rust", "rs"):
+            return "\n\n".join(m.rust for m in models)
+        elif target in ("go", "golang"):
+            return "\n\n".join(m.golang for m in models)
+        elif target in ("kt", "kotlin"):
+            return "\n\n".join(m.kotlin for m in models)
+        elif target in ("swift", "ios"):
+            return "\n\n".join(m.swift for m in models)
+        else:
+            return "\n\n".join(
+                f"// --- {m.class_name} ---\n// TypeScript:\n{m.typescript}\n\n// Rust:\n{m.rust}\n\n// Go:\n{m.golang}\n\n// Kotlin:\n{m.kotlin}\n\n// Swift:\n{m.swift}"
+                for m in models
+            )
+
+    @classmethod
+    def render_cli(cls, py_file: str, lang: str):
+        print(f"\n🌉 \033[1mT-ZERO POLYGLOT TYPE & SCHEMA TRANSPILER\033[0m")
+        print("=" * 70)
+        print(f"📄 Source Python Model: {py_file}")
+        print(f"🎯 Target Language:     \033[36m{lang.upper()}\033[0m")
+        print("=" * 70)
+        out = cls.transpile_file(py_file, target_lang=lang)
+        print(out)
+        print("=" * 70)
+

package/src/tzero_ci.py

@@ -0,0 +1,153 @@
+# -*- coding: utf-8 -*-
+"""
+Siber Akademi — T-Zero CI/CD Pipeline & Security Gate Generator.
+Developer: Toprak Ahmet Aydoğmuş (Siber Akademi)
+License: MIT
+
+Installs zero-dependency, automated CI/CD security and verification pipelines:
+  - GitHub Actions: .github/workflows/tzero_guard.yml
+  - GitLab CI: .gitlab-ci.yml
+  - Pre-commit: .pre-commit-config.yaml
+"""
+
+import sys
+if sys.platform == "win32":
+    try:
+        sys.stdout.reconfigure(encoding="utf-8")
+        sys.stderr.reconfigure(encoding="utf-8")
+    except Exception:
+        pass
+
+import os
+from typing import Tuple, Dict, Any
+
+
+GITHUB_WORKFLOW_TEMPLATE = """name: T-Zero Autonomous Quality & Zero-Leak Gate
+
+on:
+  push:
+    branches: [ main, master ]
+  pull_request:
+    branches: [ main, master ]
+
+jobs:
+  tzero-verify:
+    name: T-Zero Autonomous Verification Gate
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-24.04, windows-latest]
+        python-version: ["3.10", "3.11", "3.12"]
+
+    steps:
+      - name: Checkout Codebase
+        uses: actions/checkout@v5
+        with:
+          fetch-depth: 0
+
+      - name: Set up Python ${{ matrix.python-version }}
+        uses: actions/setup-python@v6
+        with:
+          python-version: ${{ matrix.python-version }}
+          cache: 'pip'
+
+      - name: Install Dependencies
+        run: |
+          python -m pip install --upgrade pip
+          pip install flake8 fastmcp keyring requests
+
+      - name: Zero-Leak Security & Code Quality Audit
+        run: |
+          python tzero_v3.py --audit . --format text
+
+      - name: Enforce T-4 Architectural Boundary Rules
+        run: |
+          python tzero_v3.py --enforce-boundaries tzero.rules.json
+
+      - name: Run Comprehensive Test Suite
+        run: |
+          python -m unittest discover -s tests -p "test_*.py" -v
+
+      - name: PR Incremental Token Savings Telemetry
+        if: github.event_name == 'pull_request'
+        run: |
+          python tzero_v3.py --diff HEAD~1
+"""
+
+GITLAB_CI_TEMPLATE = """stages:
+  - audit
+  - test
+
+variables:
+  PIP_CACHE_DIR: "$CI_PROJECT_DIR/.cache/pip"
+
+cache:
+  paths:
+    - .cache/pip
+
+tzero_audit:
+  stage: audit
+  image: python:3.11-slim
+  script:
+    - pip install --upgrade pip
+    - pip install fastmcp keyring requests
+    - python tzero_v3.py --audit . --format text
+    - python tzero_v3.py --enforce-boundaries tzero.rules.json
+
+tzero_tests:
+  stage: test
+  image: python:3.11-slim
+  script:
+    - pip install --upgrade pip
+    - pip install fastmcp keyring requests
+    - python -m unittest discover -s tests -p "test_*.py" -v
+"""
+
+PRE_COMMIT_CONFIG_TEMPLATE = """repos:
+  - repo: local
+    hooks:
+      - id: tzero-zero-leak
+        name: T-Zero 100% Zero-Leak Security Scanner
+        entry: python tzero_v3.py --audit .
+        language: system
+        pass_filenames: false
+        always_run: true
+
+      - id: tzero-architectural-boundaries
+        name: T-Zero Architectural Boundaries Enforcer
+        entry: python tzero_v3.py --enforce-boundaries
+        language: system
+        pass_filenames: false
+        always_run: true
+"""
+
+
+class CIPipelineGenerator:
+    """Turnkey generator for automated enterprise CI/CD verification workflows."""
+
+    @classmethod
+    def install_github_workflow(cls, repo_dir: str = ".") -> Tuple[bool, str]:
+        """Installs GitHub Actions workflow into .github/workflows/tzero_guard.yml."""
+        wf_dir = os.path.join(repo_dir, ".github", "workflows")
+        os.makedirs(wf_dir, exist_ok=True)
+        wf_path = os.path.join(wf_dir, "tzero_guard.yml")
+        with open(wf_path, "w", encoding="utf-8") as f:
+            f.write(GITHUB_WORKFLOW_TEMPLATE.strip() + "\n")
+        return True, wf_path
+
+    @classmethod
+    def install_gitlab_ci(cls, repo_dir: str = ".") -> Tuple[bool, str]:
+        """Installs GitLab CI configuration into .gitlab-ci.yml."""
+        ci_path = os.path.join(repo_dir, ".gitlab-ci.yml")
+        with open(ci_path, "w", encoding="utf-8") as f:
+            f.write(GITLAB_CI_TEMPLATE.strip() + "\n")
+        return True, ci_path
+
+    @classmethod
+    def install_pre_commit(cls, repo_dir: str = ".") -> Tuple[bool, str]:
+        """Installs pre-commit configuration into .pre-commit-config.yaml."""
+        pc_path = os.path.join(repo_dir, ".pre-commit-config.yaml")
+        with open(pc_path, "w", encoding="utf-8") as f:
+            f.write(PRE_COMMIT_CONFIG_TEMPLATE.strip() + "\n")
+        return True, pc_path