Why T-Zero?

When an AI coding assistant (Cursor, Claude Code, Antigravity IDE, Windsurf, Cline) reads your codebase, feeding full source files wastes 80% to 95% of your context window on internal loop bodies, routine calculations, and local variables. The model needs to know what your modules expose and call, not 100 lines of boilerplate implementation inside each method.

T-Zero acts like an on-the-fly .pyi / .d.ts declaration generator for your AI context window:

┌─────────────────────────────────┐
│     Full Source Codebase        │  (166,996 raw tokens — $0.50/query, 18s latency)
└────────────────┬────────────────┘
                 │
                 ▼  [ T-Zero Native AST Parser ]
                 │  Strips routine bodies, preserves signatures, types & docs
                 ▼
┌─────────────────────────────────┐
│     T-Zero AST Skeleton Tree    │  (8,465 tokens — $0.025/query, 2.1s latency)
└─────────────────────────────────┘

Before vs. After AST Pruning

# BEFORE: Raw source file (1,240 tokens)
class PaymentGateway:
    def __init__(self, api_key: str, timeout: int = 30):
        # 30 lines of connection pooling, socket configuration, SSL contexts...
        self.session = requests.Session()
        self.timeout = timeout
        ...

    def process_charge(self, user_id: str, amount_cents: int, currency: str = "USD") -> TransactionResult:
        """Charges a customer card with automated retry and idempotency."""
        # 60 lines of payload hashing, error handling, database locking, telemetry...
        if not user_id:
            raise ValueError("user_id required")
        ...

# AFTER: T-Zero AST Skeleton (64 tokens — 94.8% reduction)
class PaymentGateway:
    def __init__(self, api_key: str, timeout: int = 30): ...

    def process_charge(self, user_id: str, amount_cents: int, currency: str = "USD") -> TransactionResult:
        """Charges a customer card with automated retry and idempotency."""
        ...

The AI assistant retains full access to class names, typed parameters, docstrings, and return types — with zero semantic loss, at a fraction of the token cost, and with drastically faster Time-To-First-Token (TTFT).

Quickstart

1. Instant Run via uvx (Zero Installation)

uvx tzero-mcp

2. Install via pip

pip install tzero-mcp

3. Connect to Cursor / Claude Desktop / Antigravity / Windsurf

Add the following to your claude_desktop_config.json or Cursor Settings (Features → MCP):

{
  "mcpServers": {
    "tzero": {
      "command": "uvx",
      "args": ["tzero-mcp"]
    }
  }
}

Or using local python:

{
  "mcpServers": {
    "tzero": {
      "command": "python",
      "args": ["-m", "tzero_mcp"]
    }
  }
}

4. Claude Code CLI Integration

claude mcp add --scope user tzero uvx tzero-mcp

5. Launch Local Web Dashboard

tzero --dashboard

Opens the local browser dashboard on http://localhost:8421 featuring interactive dependency graphs and the live AST pruner sandbox.

Reproducible Benchmarks

Verify locally on your machine with zero cloud cost:

python tzero.py --savings

Core Capabilities

1. AST Skeleton Pruning

Strips internal routine execution bodies while preserving every class definition, typed signature, docstring, and return type. Zero heuristic line cutting — 100% deterministic language parsing.

2. Polyglot Language Support

Zero external compiler dependencies. Supports:

• Python (via native ast parser)
• TypeScript & JavaScript (interfaces, exports, type annotations)
• Go, Rust, Java, C#, C++, PHP, and Ruby (structural signature extractors)

3. Change Blast Radius Analysis

Before refactoring a class or function, T-Zero calculates its exact downstream dependency impact (0–100 score), identifying every file, import, and symbol that could break.

4. Zero-Leak Security Guard

Guaranteed 100% offline execution. Includes pre-commit hooks and real-time scanners that block .env secrets, private tokens, and credentials from ever being sent to LLM APIs.

5. Embedded Superdesign Engine

Natively integrates the Superdesign UI methodology into Claude Code and Cursor with 5 tools to generate design systems, component specifications, and interactive browser preview galleries.

MCP Tools Reference

🚀 Flagship Omni-Tool: execute_codebase_workflow

Execute any codebase workflow, multi-stage audit, or specific T-Zero engine in a single unified MCP command:

// Full autonomous pipeline: Security Audit + Architecture Blueprint + Token ROI + Code Quality
{
  "name": "execute_codebase_workflow",
  "arguments": {
    "action": "auto",
    "target": "."
  }
}

Or execute targeted operations on demand:

• "action": "security" — 100% Zero-Leak secret scan across workspace
• "action": "context" — Hierarchical AST context tree generation
• "action": "blueprint" — Mermaid system architecture & component topologies
• "action": "impact" — Change blast radius analysis for a class or function
• "action": "heal" — Automated AST diagnostic diagnosis & self-healing patch
• "action": "search" — Local BM25 hybrid semantic search

Tool Architecture: By default, T-Zero exposes the 15 TDQS-certified Canonical & Omni Tools to prevent context bloat and ensure 5/5 tool coherence. The full 48-tool suite is available on-demand via tzero-mcp --all or TZERO_MCP_TOOL_MODE=all (and all 48 tools remain dynamically callable via call_tool() in both modes).

T-Zero tools grouped by functional category:

Architecture

flowchart TD
    subgraph Input ["Input Layer"]
        REPO["Source Code Repository"]
    end

    subgraph Parser ["AST Engine"]
        AST["Language AST Visitor"]
        SIG["Signature & Type Extractor"]
        DEP["Import & Call Graph Analyzer"]
    end

    subgraph Core ["T-Zero Engine"]
        PRUNER["AST Skeleton Pruner (-94.9% Tokens)"]
        GUARD["100% Zero-Leak Security Guard"]
        SUPER["Superdesign UI Engine"]
    end

    subgraph Delivery ["MCP Delivery"]
        MCP["tzero_mcp.py (Stdio Server)"]
        DASH["tzero --dashboard (localhost:8421)"]
    end

    subgraph Clients ["AI Clients"]
        CURSOR["Cursor IDE"]
        CLAUDE["Claude Code / Desktop"]
        AGY["Antigravity IDE"]
        WINDSURF["Windsurf / Cline"]
    end

    REPO --> AST
    AST --> SIG
    AST --> DEP
    SIG --> PRUNER
    DEP --> PRUNER
    PRUNER --> GUARD
    GUARD --> MCP
    SUPER --> MCP
    PRUNER --> DASH
    MCP --> CURSOR
    MCP --> CLAUDE
    MCP --> AGY
    MCP --> WINDSURF

Security Architecture

100% Zero-Leak Guarantee: T-Zero contains ZERO hardcoded, personal, or public API keys. All AST parsing, BM25 indexing, and blast radius calculations run 100% locally on your machine with zero external network telemetry.

🇹🇷 Türkçe Dokümantasyon

T-Zero, yapay zeka kodlama ajanları (Cursor, Claude Code, Antigravity IDE, Windsurf, Cline) için geliştirilmiş, kod tabanı bağlamını yapısal olarak koruyarak token tüketimini %94.9'a kadar azaltan açık kaynaklı bir bağlam motoru ve Model Context Protocol (MCP) sunucusudur.

Neden T-Zero?

Bir AI asistanına binlerce satırlık ham kod dosyaları verildiğinde, fonksiyonların içindeki döngüler ve rutin işlemler bağlam penceresini gereksiz yere doldurur. T-Zero, kod tabanını derleyici seviyesinde AST ile ayrıştırarak fonksiyon gövdelerini çıkarır; yalnızca sınıf yapılarını, tip imzalarını, docstring'leri ve bağımlılıkları korur.

Hızlı Kurulum

# Kurulum yapmadan doğrudan çalıştırmak için (uvx):
uvx tzero-mcp

# veya pip ile kurun:
pip install tzero-mcp

# Yerel görsel paneli açın:
tzero --dashboard

License & Author

• Author: Toprak Ahmet Aydoğmuş
• LinkedIn: Toprak Ahmet Aydoğmuş
• Bio & Hub: hopp.bio/siberegitim
• License: MIT License