axe-cli 1.8.2__py3-none-any.whl → 1.8.3__py3-none-any.whl

axe_cli/README.md

@@ -122,13 +122,6 @@ max_retries_per_step = 3
 max_ralph_iterations = 0
 reserved_context_size = 50000
 
-[services.search]
-base_url = "https://api.example.com/search"
-api_key = "sk-xxx"
-
-[services.fetch]
-base_url = "https://api.example.com/fetch"
-api_key = "sk-xxx"
 
 [mcp.client]
 tool_call_timeout_ms = 60000

axe_cli/agents/README.md

@@ -8,6 +8,10 @@ axe isn't limited to one main agent. You can create subagents and tasks for *any
 
 Need a dedicated security researcher? A ruthlessly precise code reviewer? A creative copywriter? axe can create and deploy specialized subagents based on your exact requirements. These subagents help you complete tasks better, faster, and more efficiently—operating with lethal precision to divide and conquer complex workflows.
 
+![subagents in action](../../assets/axe_gif_subagents.gif)
+
+**Subagents enable parallel task execution:** Spawn multiple specialized agents to work on different aspects of a problem simultaneously, each with their own context and tools.
+
 ## Built-in agents
 
 axe provides two built-in agents. You can select one at startup with the `--agent` flag:

axe_cli-1.8.3.dist-info/METADATA

@@ -0,0 +1,686 @@
+Metadata-Version: 2.3
+Name: axe-cli
+Version: 1.8.3
+Summary: axe, yerrrr
+Requires-Dist: agent-client-protocol==0.7.0
+Requires-Dist: axe-dig
+Requires-Dist: aiofiles>=24.0,<26.0
+Requires-Dist: aiohttp==3.13.3
+Requires-Dist: typer==0.21.1
+Requires-Dist: kosong[contrib]==0.41.0
+Requires-Dist: loguru>=0.6.0,<0.8
+Requires-Dist: prompt-toolkit==3.0.52
+Requires-Dist: pillow==12.1.0
+Requires-Dist: pyyaml==6.0.3
+Requires-Dist: rich==14.2.0
+Requires-Dist: ripgrepy==2.2.0
+Requires-Dist: streamingjson==0.0.5
+Requires-Dist: trafilatura==2.0.0
+Requires-Dist: lxml==6.0.2
+Requires-Dist: tenacity==9.1.2
+Requires-Dist: fastmcp==2.12.5
+Requires-Dist: pydantic==2.12.5
+Requires-Dist: httpx[socks]==0.28.1
+Requires-Dist: pykaos==0.6.0
+Requires-Dist: batrachian-toad==0.5.23 ; python_full_version >= '3.14'
+Requires-Dist: tomlkit==0.14.0
+Requires-Dist: jinja2==3.1.6
+Requires-Dist: pyobjc-framework-cocoa>=12.1 ; sys_platform == 'darwin'
+Requires-Dist: keyring>=25.7.0
+Requires-Dist: tiktoken>=0.8.0
+Requires-Python: >=3.13
+Description-Content-Type: text/markdown
+
+# axe: The Agent Built for Real Engineers
+
+**What it really means to be a 10x engineer—and the tool built for that reality.**
+
+![axe in action](assets/axe_gif_axe_axe_ending.gif)
+
+---
+
+## what do you mean by a "10x engineer"
+
+The industry loves the lore of "10x engineer"—the lone genius who ships a new product in a weekend, the hacker who rewrites the entire stack in a caffeine-fueled sprint, the visionary who creates something from nothing.
+
+**That's not what a 10x engineer actually does.**
+
+The real 10x engineers aren't working on greenfield projects. They're not inventing new frameworks or building the next viral app. They're maintaining **behemoth codebases** where millions of users depend on their decisions every single day.
+
+Their incentive structure is fundamentally different: **"If it's not broken, don't fix it."**
+
+And with that constraint in mind, they ask a different question entirely:
+
+> **"What truly matters for solving this particular problem, and how can I gain enough confidence to ship it reliably?"**
+
+---
+
+## The Real Engineering Challenge
+
+**Idea creation is a human trait.** Ideas arise from impulsive feelings, obstacles we encounter, problems we want to solve. Creating something new is exciting, visceral, immediate.
+
+**Maintaining something reliably over time requires a completely different pedigree**—and it's by far more important than creating the idea itself.
+
+Consider the reality:
+- A production codebase with **100,000+ lines** across hundreds of files
+- **Millions of users** whose workflows depend on your system staying stable
+- **Years of accumulated complexity**: edge cases, performance optimizations, backwards compatibility
+- **Distributed teams** where no single person understands the entire system
+- **The cost of breaking things** is measured in downtime, lost revenue, and user trust
+
+In this environment, the questions that matter are:
+- "If I change this function, what breaks?"
+- "How does this data flow through the system?"
+- "What are all the execution paths that touch this code?"
+- "Where are the hidden dependencies I need to understand before refactoring?"
+
+**This is where most coding tools fail.**
+
+They're built for the weekend hackathon, the demo video, the "move fast and break things" mentality. They optimize for speed of creation, not confidence in maintenance.
+
+---
+
+## Enter axe
+
+We built axe because we understood this problem intimately. Our team has been maintaining production systems at scale, and we needed a tool that matched the way **real engineering** actually works.
+
+**axe is built for large codebases.** Not prototypes. Not "good enough for now" solutions.
+
+It's built for the engineer who needs to:
+- Understand a **call graph** before changing a function signature
+- Trace **data flow** to debug a subtle state corruption
+- Analyze **execution paths** to understand why a test fails in CI but not locally
+- Perform **impact analysis** before refactoring to know exactly what depends on what
+
+**The core insight:** To ship reliably in large codebases, you need **precise understanding**, not exhaustive reading.
+
+
+---
+
+## How axe Works: Precision Through Intelligence
+
+Most coding tools take the brute-force approach: dump your entire codebase into the context window and hope the LLM figures it out.
+
+**This is backwards.**
+
+axe uses **axe-dig**, a 5-layer code intelligence engine that extracts **exactly what matters** for the task at hand:
+
+```
+┌──────────────────────────────────────────────────────────────┐
+│ Layer 5: Program Dependence  → "What affects line 42?"      │
+│ Layer 4: Data Flow           → "Where does this value go?"  │
+│ Layer 3: Control Flow        → "How complex is this?"       │
+│ Layer 2: Call Graph          → "Who calls this function?"   │
+│ Layer 1: AST                 → "What functions exist?"      │
+└──────────────────────────────────────────────────────────────┘
+```
+
+**This isn't about saving tokens.** It's about **technical precision.**
+
+When you need to understand a function, axe-dig gives you:
+- The function signature and what it does
+- **Forward call graph**: What does this function call?
+- **Backward call graph**: Who calls this function?
+- **Control flow complexity**: How many execution paths exist?
+- **Data flow**: How do values transform through this code?
+- **Impact analysis**: What breaks if I change this?
+
+Sometimes this means fetching **more context**, not less. When you're debugging a race condition or tracing a subtle bug through multiple layers, axe-dig will pull in the full dependency chain—because **correctness matters more than brevity**.
+
+The goal isn't minimalism. **The goal is confidence.**
+
+---
+
+## A Real Example: Understanding Before Changing
+
+Let's say you need to refactor a payment processing function in a production system.
+
+**The wrong approach** (most tools):
+1. Read the entire `payment.py` file (4,200 tokens)
+2. Read related files the LLM thinks might be relevant (15,000+ tokens)
+3. Make changes based on incomplete understanding
+4. Hope nothing breaks
+
+**The axe approach**:
+
+```bash
+# 1. Understand what this function does
+chop context process_payment --project . --depth 2
+
+# Result: ~175 tokens
+# - Function signature
+# - What it calls: validate_card, stripe.charge, db.save_transaction
+# - Complexity: 3 decision points
+# - Data flow: card → card_valid → charge → transaction
+```
+
+```bash
+# 2. See who depends on this (impact analysis)
+chop impact process_payment .
+
+# Result: Shows exactly which functions call this
+# - payment.py: update_subscription (line 134)
+# - subscription.py: renew_subscription (line 45)
+# - tests/test_payment.py: 8 test functions
+```
+
+```bash
+# 3. Understand the full execution path
+chop slice src/payment.py process_payment 89
+
+# Result: Only the 6 lines that affect the return value
+# Not the entire 180-line function
+```
+
+**Now you can refactor with confidence.** You know:
+- What the function does
+- What depends on it
+- What execution paths exist
+- What data flows through it
+
+**This is what enables reliable shipping.**
+
+---
+
+## The axe-dig Difference: Side-by-Side Comparison
+
+To demonstrate the precision advantage, we built a minimal CLI agent implementation with basic tools (grep, edit, write, shell) and compared it against the same agent with axe-dig tools.
+
+**Note:** These are intentionally minimal implementations to show how phenomenal the axe-dig difference is.
+
+### Example 1: Basic Edit Operations
+
+![comparison](assets/axe_gif_comparison.gif)
+
+**Left:** Basic CLI agent with grep  
+**Right:** axe CLI with axe-dig
+
+The difference is clear. The basic agent searches blindly, while axe-dig understands code structure and dependencies.
+
+### Example 2: Understanding Call Flow Tracers
+
+When asked to explain how call flow tracking works, both agents found the context—but the results were dramatically different.
+
+![call flow part 1](assets/axe_gif_explain_dig.gif)
+
+**Left:** Had to read the entire file after grepping for literal strings. **44,000 tokens**.  
+**Right:** axe-dig used **17,000 tokens** while also discovering:
+- Call graphs for the decorator used on tracer functions
+- Thread-safe depth tracking mechanisms
+- How functions using this decorator actually work
+
+axe-dig didn't just use fewer tokens—it provided **better understanding** of how the code flows.
+
+### Example 3: The Compounding Effect
+
+The difference compounds with follow-up questions. When we asked about caller information:
+
+![call flow part 2](assets/axe_gif_call_flow_compounding.gif)
+
+**Left:** Started wrong, inferred wrong, continued wrong.  
+**Right:** Had more context and better understanding from the start, leading to precise answers.
+
+**This is why axe doesn't just optimize for token savings—it optimizes for what the code actually does and how it flows.**
+
+### Example 4: Active Search vs. Passive Explanation
+
+In the mlx-lm codebase, when asked how to compute DWQ targets:
+
+![better inference](assets/axe_gif_better_inference.gif)
+
+**Left:** Explained the concept generically.  
+**Right:** axe CLI actively searched the codebase and found the actual implementation.
+
+**Precision means finding the answer in your code, not explaining theory.**
+
+---
+
+## Token Efficiency: A Consequence, Not the Goal
+
+Yes, axe-dig achieves **95% token reduction** compared to reading raw files.
+
+| Scenario | Raw Tokens | axe-dig Tokens | Savings |
+|----------|------------|----------------|---------|
+| Function + callees | 21,271 | 175 | **99%** |
+| Codebase overview (26 files) | 103,901 | 11,664 | 89% |
+| Deep call chain (7 files) | 53,474 | 2,667 | 95% |
+
+But **this isn't why axe exists.**
+
+Token efficiency is a **byproduct of precision**. When you extract only the information needed to make a correct decision, you naturally use fewer tokens than dumping everything.
+
+However, axe-dig is **not a token-saving machine**. When the situation demands it—when you need to trace a complex bug through multiple layers, when you need to understand how a feature connects throughout the codebase—axe-dig will fetch **more context**, not less.
+
+**The principle:** Fetch exactly what's needed for technical precision. Sometimes that's 175 tokens. Sometimes it's 15,000 tokens. The difference is **intentionality**.
+
+Other tools are incentivized to burn tokens (they charge per token). axe is incentivized to **get the answer right**.
+
+---
+
+## Built for Local Intelligence
+
+axe was designed with **local compute and local LLMs** in mind.
+
+Why does this matter?
+
+Local LLMs have different constraints than cloud APIs:
+- **Slower prefill and decoding** (can't waste time on irrelevant context)
+- **Smaller context windows** (need precision, not bloat)
+- **No per-token billing** (optimization is about speed and accuracy, not cost)
+
+This forced us to build a **precise retrieval engine** from the ground up. We couldn't rely on "dump everything and let the cloud LLM figure it out."
+
+The result: **axe works brilliantly with both local and cloud models**, because precision benefits everyone.
+
+### Running Locally: Real-World Performance
+
+Here's axe running with **srswti/blackbird-she-doesnt-refuse-21b**—a 21B parameter model from our Bodega collection, running entirely locally:
+
+![local model demonstration](assets/axe_gif_subagents.gif)
+
+**Hardware:** M1 Max, 64GB RAM  
+**Model:** Bodega Blackbird 21B (local inference)  
+**Performance:** Spawning subagents, parallel task execution, full agentic capabilities
+
+As you can see, the capability of axe-optimized Bodega models running locally is exceptional. The precision retrieval engine means even local models can handle complex workflows efficiently—because they're not wasting compute on irrelevant context.
+
+---
+
+## The axe-dig Advantage: Semantic Search
+
+Traditional search finds syntax. **axe-dig semantic search finds behavior.**
+
+```bash
+# Traditional grep
+grep "cache" src/  # Finds: variable names, comments, "cache_dir"
+
+# axe-dig semantic search
+chop semantic search "memoize expensive computations with TTL expiration"
+
+# Finds: get_user_profile() because:
+# - It calls redis.get() and redis.setex() (caching pattern)
+# - Has TTL parameter in redis.setex call
+# - Called by functions that do expensive DB queries
+# Even though it doesn't mention "memoize" or "TTL"
+```
+
+Every function gets embedded with:
+- Signature and docstring
+- **Forward and backward call graphs**
+- **Complexity metrics** (branches, loops, cyclomatic complexity)
+- **Data flow patterns** (variables used and transformed)
+- **Dependencies** (imports, external modules)
+- First ~10 lines of implementation
+
+This gets encoded into **1024-dimensional embeddings**, indexed with FAISS for fast similarity search.
+
+**Find code by what it does, not what it's named.**
+
+---
+
+## Daemon Architecture: 300x Faster Queries
+
+**The old way:** Every query spawns a new process, parses the entire codebase, builds indexes, returns result, exits. ~30 seconds.
+
+**axe-dig's daemon:** Long-running background process with indexes in RAM. ~100ms.
+
+| Command | Daemon | CLI Spawn | Speedup |
+|---------|--------|-----------|---------|
+| `search` | 0.2ms | 72ms | **302x** |
+| `extract` | 9ms | 97ms | **11x** |
+| `impact` | 0.2ms | 1,129ms | **7,374x** |
+| `structure` | 0.6ms | 181ms | **285x** |
+| **Average** | **10ms** | **1,555ms** | **155x** |
+
+**Why `impact` shows 7,374x speedup:** The CLI must rebuild the entire call graph from scratch on every invocation (~1.1 seconds). The daemon keeps the call graph in memory, so queries return in <1ms.
+
+**Incremental updates:** When you edit one function, axe-dig doesn't re-analyze the entire codebase. Content-hash-based caching with automatic dependency tracking means **10x faster incremental updates**.
+
+---
+
+## Real-World Workflow: Debugging a Production Bug
+
+**Scenario:** Users sometimes get stale data even after updates.
+
+```bash
+# 1. Find where the error occurs
+chop search "get_user" src/
+
+# 2. Get the program slice (what code affects the return value?)
+chop slice src/db.py get_user 45
+
+# Output shows only the 6 relevant lines:
+# 12:  cached = redis.get(f"user:{user_id}")
+# 15:  if cached:
+# 18:      return json.loads(cached)
+# 23:  user = db.query("SELECT * FROM users WHERE id = ?", user_id)
+# 34:  redis.setex(f"user:{user_id}", 3600, json.dumps(user))
+# 45:  return user
+
+# 3. Find who calls this (to see if cache is invalidated on update)
+chop impact get_user src/
+
+# 4. Search for update functions
+chop semantic search "update user data in database" src/
+# Finds update_user() but it doesn't call redis.delete()!
+
+# 5. Check data flow in update_user
+chop dfg src/db.py update_user
+# Shows: updates DB but never invalidates cache
+```
+
+**Result:** Found the bug—cache invalidation missing in `update_user()`. 4 commands, 3 minutes.
+
+**Before axe-dig:** Read multiple files, manually trace execution, spend 45 minutes debugging, maybe miss the issue entirely.
+
+**With axe-dig:** Surgical precision. Confidence to ship the fix.
+
+---
+
+## Core Capabilities
+
+### Code Intelligence (powered by axe-dig)
+
+| Tool | What it does | Use case |
+|------|-------------|----------|
+| **CodeSearch** | Semantic search by behavior | "Find payment processing logic" |
+| **CodeContext** | LLM-ready function summaries with call graphs | Understand unfamiliar code |
+| **CodeStructure** | Navigate functions/classes in files/dirs | Explore new codebases |
+| **CodeImpact** | Reverse call graph (who calls this?) | Safe refactoring |
+
+### File Operations
+- `ReadFile` / `WriteFile` / `StrReplaceFile` - Standard file I/O
+- `Grep` - Exact file locations + line numbers (use after CodeSearch)
+- `Glob` - Pattern matching
+- `ReadMediaFile` - Images, PDFs, videos
+
+### Multi-Agent Workflows
+- `Task` - Spawn subagents for parallel work
+- `CreateSubagent` - Custom agent specs
+- `SetTodoList` - Track multi-step tasks
+
+**Subagents in action:**
+
+![subagents](assets/axe_gif_subagents.gif)
+
+Spawn specialized subagents to divide and conquer complex workflows. Each subagent operates independently with its own context and tools.
+
+---
+
+## Quick Start
+
+### Install
+```bash
+# Install axe-cli (includes axe-dig)
+uv pip install axe-cli
+
+# Or from source
+git clone https://github.com/SRSWTI/axe-cli
+cd axe-cli
+make prepare
+make build
+```
+
+### Run
+```bash
+cd /path/to/your/project
+axe
+```
+
+On first run, axe-dig automatically indexes your codebase (30-60 seconds for typical projects). After that, queries are instant.
+
+### Start Using
+```bash
+# greet axe
+hiii
+
+# start coding
+hey axe, can you tell me how does dwq targets are computed in mlx
+
+# Toggle to shell mode
+[Ctrl+X]
+pytest tests/
+[Ctrl+X]
+```
+Hit **Ctrl+X** to toggle between axe and your normal shell. No context switching. No juggling terminals.
+
+![shell toggle](assets/axe_gif_axe_sample_toggle_shell.gif)
+
+---
+
+## Powered by SRSWTI Inc.
+
+**Building the world's fastest retrieval and inference engines.**
+
+### Bodega Inference Engine
+
+Exclusive models trained/optimized for Bodega Inference Engine. axe includes **zero-day support** for all Bodega models, ensuring immediate access to our latest breakthroughs.
+
+**Note:** Our models are also available on [🤗 Hugging Face](https://huggingface.co/srswti).
+
+#### Raptor Series
+Ultra-compact reasoning models designed for efficiency and edge deployment. **Super light**, amazing agentic coding capabilities, robust tool support, minimal memory footprint.
+
+- [🤗 **bodega-raptor-0.9b**](https://huggingface.co/srswti/bodega-raptor-0.9b) - 900M params. Runs on base m4 air with 100+ tok/s.
+- [🤗 **bodega-raptor-90m**](https://huggingface.co/srswti/bodega-raptor-90m) - Extreme edge variant. Sub-100M params for amazing tool calling.
+- [🤗 **bodega-raptor-1b-reasoning-opus4.5-distill**](https://huggingface.co/srswti/bodega-raptor-1b-reasoning-opus4.5-distill) - Distilled from Claude Opus 4.5 reasoning patterns.
+- [🤗 **bodega-raptor-8b-mxfp4**](https://huggingface.co/srswti/bodega-raptor-8b-mxfp4) - Balanced power/performance for laptops.
+- [🤗 **bodega-raptor-15b-6bit**](https://huggingface.co/srswti/bodega-raptor-15b-6bit) - Enhanced raptor variant.
+
+#### Flagship Models
+Frontier intelligence, distilled and optimized.
+
+- [🤗 **deepseek-v3.2-speciale-distilled-raptor-32b-4bit**](https://huggingface.co/srswti/deepseek-v3.2-speciale-distilled-raptor-32b-4bit) - DeepSeek V3.2 distilled to 32B with Raptor reasoning. Exceptional math/code generation in 5-7GB footprint. 120 tok/s on M1 Max.
+- [🤗 **bodega-centenario-21b-mxfp4**](https://huggingface.co/srswti/bodega-centenario-21b-mxfp4) - Production workhorse. 21B params optimized for sustained inference workloads.
+- [🤗 **bodega-solomon-9b**](https://huggingface.co/srswti/bodega-solomon-9b) - Multimodal and best for agentic coding.
+
+#### Axe-Turbo Series
+**Launched specifically for the Axe coding use case.** High-performance agentic coding models optimized for the Axe ecosystem.
+
+- [🤗 **axe-turbo-1b**](https://huggingface.co/srswti/axe-turbo-1b) - 1B params, 150 tok/s, sub-50ms first token. Edge-first architecture.
+- [🤗 **axe-turbo-31b**](https://huggingface.co/srswti/axe-turbo-31b) - High-capacity workloads. Exceptional agentic capabilities.
+
+#### Specialized Models
+Task-specific optimization.
+
+- [🤗 **bodega-vertex-4b**](https://huggingface.co/srswti/bodega-vertex-4b) - 4B params. Optimized for structured data.
+- [🤗 **blackbird-she-doesnt-refuse-21b**](https://huggingface.co/srswti/blackbird-she-doesnt-refuse-21b) - Uncensored 21B variant for unrestricted generation.
+
+### Using Bodega Models
+
+Configure Bodega in `~/.axe/config.toml`:
+
+```toml
+default_model = "bodega-raptor"
+
+[providers.bodega]
+type = "bodega"
+base_url = "http://localhost:44468"  # Local Bodega server
+api_key = ""
+
+[models.bodega-raptor]
+provider = "bodega"
+model = "srswti/bodega-raptor-8b-mxfp4"
+max_context_size = 32768
+capabilities = ["thinking"]
+
+[models.bodega-turbo]
+provider = "bodega"
+model = "srswti/axe-turbo-31b"
+max_context_size = 32768
+capabilities = ["thinking"]
+```
+
+See [sample_config.toml](sample_config.toml) for more examples including OpenRouter, Anthropic, and OpenAI configurations.
+
+---
+
+## Documentation Index
+
+We've organized the docs to make them digestible. Here's what's where:
+
+### [Common Use Cases & Workflows](examples/README.md)
+Learn how to use axe for implementing features, fixing bugs, understanding unfamiliar code, and automating tasks. Includes real workflow examples for debugging, refactoring, and exploration.
+
+### [Built-in Tools](src/axe_cli/tools/README.md)
+Complete reference for all available tools: file operations, shell commands, multi-agent tasks, and the axe-dig code intelligence tools. Every tool is designed for precision, not guesswork.
+
+### [Agent Skills](src/axe_cli/skills/README.md)
+How to create and use specialized skills to extend axe's capabilities. Skills are reusable workflows and domain expertise that you can invoke with `/skill:name` commands. Turn your team's best practices into executable knowledge.
+
+### [Agents & Subagents](src/axe_cli/agents/README.md)
+Guide to creating custom agents and spawning specialized subagents for parallel work. These subagents operate with precision to divide and conquer complex workflows.
+
+### [Technical Reference](src/axe_cli/README.md)
+Deep dive into configuration (providers, models, loop control), session management, architecture, and MCP integration. Everything you need to customize axe for your workflow.
+
+### [axe-dig: Code Intelligence Engine](docs/AXE-DIG.md)
+**The secret weapon.** Complete documentation on axe-dig's 5-layer architecture, semantic search, daemon mode, and program slicing. Learn how to extract precise context while preserving everything needed for correct edits. Includes performance benchmarks, real-world debugging workflows, and the design rationale behind every choice. **This is what makes axe different from every other coding tool.**
+
+---
+
+## What's Coming
+
+Our internal team has been using features that will change the game:
+
+### 1. Interactive Dashboard: Visualize Your Codebase
+
+Understanding code isn't just about reading—it's about **seeing** the structure, connections, and flow.
+
+The dashboard provides real-time visualization for:
+
+**Code Health Analysis:**
+- **Cyclic dependencies**: Visualize circular imports and dependency loops that make refactoring dangerous
+- **Dead code detection**: See unreachable functions and unused modules with connection graphs
+- **Safe refactoring zones**: Identify code that can be changed without cascading effects
+- **Execution trace visualization**: Watch the actual flow of data through your system at runtime
+
+**Debugging Workflows:**
+- Trace execution paths visually from entry point to crash
+- See which functions are called, in what order, with what values
+- Identify bottlenecks and performance hotspots in the call graph
+- Understand data transformations across multiple layers
+
+The dashboard turns axe-dig's 5-layer analysis into interactive, explorable visualizations. No more drawing diagrams on whiteboards—axe generates them from your actual code.
+
+### 2. Execution Tracing
+
+See what actually happened at runtime. No more guessing why a test failed.
+
+```bash
+# Trace a failing test
+/trace pytest tests/test_payment.py::test_refund
+
+# Shows exact values that flowed through each function:
+# process_refund(amount=Decimal("50.00"), transaction_id="tx_123")
+#   → validate_refund(transaction=Transaction(status="completed"))
+#     → check_refund_window(created_at=datetime(2024, 1, 15))
+#       → datetime.now() - created_at = timedelta(days=45)
+#       → raised RefundWindowExpired  # ← 30-day window exceeded
+```
+
+### 3. Monorepo Factoring (Enterprise Feature)
+
+**Status:** Under active development. Our team has been using this internally for weeks.
+
+Large monorepos become unmaintainable when everything is tangled together. axe analyzes your codebase and automatically factors it into logical modules based on:
+
+- **Dependency analysis**: Which code actually depends on what
+- **Call graph clustering**: Functions that work together, grouped together
+- **Data flow boundaries**: Natural separation points in your architecture
+- **Usage patterns**: How different parts of the codebase are actually used
+
+**The result:** Clear module boundaries, reduced coupling, easier maintenance. This has been heavily requested by enterprise customers managing multi-million-line monorepos.
+
+**Example workflow:**
+```bash
+# Analyze current structure
+/monorepo analyze .
+
+# Shows: 47 logical modules detected across 1,200 files
+# Suggests: Split into 5 packages with clear boundaries
+# Impact: Reduces cross-module dependencies by 73%
+
+# Apply factoring
+/monorepo factor --target packages/
+```
+
+### 4. Language Migration (X → Y)
+
+Migrating codebases between languages is notoriously error-prone. axe uses its deep understanding of code structure to enable reliable migrations:
+
+**How it works:**
+1. **Analyze source code**: Extract call graphs, data flow, and business logic
+2. **Preserve semantics**: Understand what the code does, not just what it says
+3. **Generate target code**: Translate to the new language while maintaining behavior
+4. **Verify correctness**: Compare execution traces and test coverage
+
+**Supported migrations:**
+- Python → TypeScript (preserve type safety)
+- JavaScript → Go (maintain concurrency patterns)
+- Ruby → Rust (keep performance characteristics)
+- Java → Kotlin (modernize while preserving architecture)
+
+Unlike simple transpilers, axe understands your code's **intent** and translates it idiomatically to the target language.
+
+### 5. Performance Debugging
+
+Flame graphs and memory profiling integrated directly in the chat interface.
+
+```bash
+# Generate flame graph
+/flamegraph api_server.py
+
+# Find memory leaks
+/memory-profile background_worker.py
+```
+
+### 6. Smart Test Selection
+
+```bash
+# Only run tests affected by your changes
+/test-impact src/payment/processor.py
+
+# Shows: 12 tests need to run (not all 1,847)
+```
+
+---
+
+## Supported Languages
+
+Python, TypeScript, JavaScript, Go, Rust, Java, C, C++, Ruby, PHP, C#, Kotlin, Scala, Swift, Lua, Elixir
+
+Language auto-detected. Specify with `--lang` if needed.
+
+---
+
+## Comparison
+
+| Feature | Claude Code | OpenAI Codex | axe |
+|---------|-------------|--------------|-----|
+| **Built for** | Weekend projects | Demos | Production codebases |
+| **Context strategy** | Dump everything | Dump everything | Extract signal (precision-first) |
+| **Code search** | Text/regex | Text/regex | Semantic (behavior-based) |
+| **Call graph analysis** | ❌ | ❌ | ✅ 5-layer analysis |
+| **Precision optimization** | ❌ (incentivized to waste) | ❌ (incentivized to waste) | ✅ Fetch what's needed for correctness |
+| **Execution tracing** | ❌ | ❌ | ✅ Coming soon |
+| **Flame graphs** | ❌ | ❌ | ✅ Coming soon |
+| **Memory profiling** | ❌ | ❌ | ✅ Coming soon |
+| **Visual debugging** | ❌ | ❌ | ✅ Coming soon |
+| **Shell integration** | ❌ | ❌ | ✅ Ctrl+X toggle |
+| **Session management** | Limited | Limited | ✅ Full history + replay |
+| **Skills system** | ❌ | ❌ | ✅ Modular, extensible |
+| **Subagents** | ❌ | ❌ | ✅ Parallel task execution |
+| **Battle-tested** | Public beta | Public API | 6 months internal use |
+
+---
+
+## Community
+
+- **Issues**: [GitHub Issues](https://github.com/SRSWTI/axe-cli/issues)
+- **Discussions**: [GitHub Discussions](https://github.com/SRSWTI/axe-cli/discussions)
+- **Docs**: [Full documentation](https://axe-cli.dev/docs)
+
+## Acknowledgements
+
+Special thanks to [MoonshotAI/kimi-cli](https://github.com/MoonshotAI/kimi-cli) for their amazing work, which inspired our tools and the Kosong provider.

{axe_cli-1.8.2.dist-info → axe_cli-1.8.3.dist-info}/RECORD

@@ -1,5 +1,5 @@
 axe_cli/CHANGELOG.md,sha256=SGSnQvv2yk7kG6yVGqS8q44PLc9g4BcaCxXkFT_rMNw,16
-axe_cli/README.md,sha256=nMESVr_BTlOz2Ie_7EqUGDIjX7I7uJIHHnpL085pheA,10748
+axe_cli/README.md,sha256=fLu7kWkfAbm_48VsAXXUD5yYAfMeq5VlMc-iAdZVEag,10587
 axe_cli/__init__.py,sha256=nnr9vBuaOPg3n4pkn07f4cvBIcjtqwTtyK26CKjSFCI,206
 axe_cli/acp/AGENTS.md,sha256=mWGID3bdGIIdlWGaLH09yN7KgQ_1mCPpqHjRUdXTjfc,4703
 axe_cli/acp/__init__.py,sha256=pDSEbgArG80xXe482DRrs4mt9lElrmFsw3Ss51lvTNU,391
@@ -10,7 +10,7 @@ axe_cli/acp/server.py,sha256=ABCOQZGofXA2XlvwRPiNnf5BSNg-TUi5JGycWIwQKI0,14213
 axe_cli/acp/session.py,sha256=92iMe_an-SWZpaIpXTv5auzVQLKzHHHx2bwYUsIxdlk,16952
 axe_cli/acp/tools.py,sha256=1HAhkr-ywLcWMnnrYiNidSH5rSwewzb_Yc6D-vbiJgU,5833
 axe_cli/acp/types.py,sha256=XpFjCPTAkmK-_NtFsL1C82UlQ2O88ngGmEaRp8bFgPQ,348
-axe_cli/agents/README.md,sha256=jznLWPa95oB6PAOZJCmDVqjGjfh8hgsAJUrt0FRyeLc,4844
+axe_cli/agents/README.md,sha256=h63I0jiFsuWdKBOvwunZS1K9a9J_bUJEn36JkDSclWg,5082
 axe_cli/agents/default/agent.yaml,sha256=TtuTy3l5GyHvsDpnikXvpo6VuxhCmPg-_D_5lQhoQDE,980
 axe_cli/agents/default/sub.yaml,sha256=bt4sqKHfhqr4ktUBBUidLGTYDlnHq7ZYjufA4FKC0dE,685
 axe_cli/agents/default/system.md,sha256=lO8T0XFEDdABn4n9W-gmsgirfDuP0O3blsnuNqL8ySw,13519
@@ -152,7 +152,7 @@ axe_cli/wire/protocol.py,sha256=hzlvXrvex6kL1eqltGDedvF1CrGY_8dINMMVluF_J1c,77
 axe_cli/wire/serde.py,sha256=v7MsE35R6Uy7ypynRaPG3iOdj4gkxzNprgaVmVVymBQ,742
 axe_cli/wire/server.py,sha256=oNjJUdALTL91ygEYsP4c4lWJ57T3Z7RIbd78nWH7O94,21218
 axe_cli/wire/types.py,sha256=O_uvsRoc5Xa7ODVcTYB9Po47cuLUErbEOhbA2qpUxOI,10597
-axe_cli-1.8.2.dist-info/WHEEL,sha256=fAguSjoiATBe7TNBkJwOjyL1Tt4wwiaQGtNtjRPNMQA,80
-axe_cli-1.8.2.dist-info/entry_points.txt,sha256=IOP2TaPtunLm5FigWdAF1KAzg7n6zN4L_JRNWbSm8Wg,41
-axe_cli-1.8.2.dist-info/METADATA,sha256=giYy6SIxd90GAQbH6Rks6nIMUa5Tc2C1HVr3jEmFZOY,21989
-axe_cli-1.8.2.dist-info/RECORD,,
+axe_cli-1.8.3.dist-info/WHEEL,sha256=5DEXXimM34_d4Gx1AuF9ysMr1_maoEtGKjaILM3s4w4,80
+axe_cli-1.8.3.dist-info/entry_points.txt,sha256=IOP2TaPtunLm5FigWdAF1KAzg7n6zN4L_JRNWbSm8Wg,41
+axe_cli-1.8.3.dist-info/METADATA,sha256=Ma3oxusFOsvrQNngIzP8x5dyAVgEi6kzQ-N0IjdUSfo,27989
+axe_cli-1.8.3.dist-info/RECORD,,

{axe_cli-1.8.2.dist-info → axe_cli-1.8.3.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: uv 0.9.28
+Generator: uv 0.9.29
 Root-Is-Purelib: true
 Tag: py3-none-any

axe_cli-1.8.2.dist-info/METADATA

@@ -1,492 +0,0 @@
-Metadata-Version: 2.3
-Name: axe-cli
-Version: 1.8.2
-Summary: axe, yerrrr
-Requires-Dist: agent-client-protocol==0.7.0
-Requires-Dist: axe-dig
-Requires-Dist: aiofiles>=24.0,<26.0
-Requires-Dist: aiohttp==3.13.3
-Requires-Dist: typer==0.21.1
-Requires-Dist: kosong[contrib]==0.41.0
-Requires-Dist: loguru>=0.6.0,<0.8
-Requires-Dist: prompt-toolkit==3.0.52
-Requires-Dist: pillow==12.1.0
-Requires-Dist: pyyaml==6.0.3
-Requires-Dist: rich==14.2.0
-Requires-Dist: ripgrepy==2.2.0
-Requires-Dist: streamingjson==0.0.5
-Requires-Dist: trafilatura==2.0.0
-Requires-Dist: lxml==6.0.2
-Requires-Dist: tenacity==9.1.2
-Requires-Dist: fastmcp==2.12.5
-Requires-Dist: pydantic==2.12.5
-Requires-Dist: httpx[socks]==0.28.1
-Requires-Dist: pykaos==0.6.0
-Requires-Dist: batrachian-toad==0.5.23 ; python_full_version >= '3.14'
-Requires-Dist: tomlkit==0.14.0
-Requires-Dist: jinja2==3.1.6
-Requires-Dist: pyobjc-framework-cocoa>=12.1 ; sys_platform == 'darwin'
-Requires-Dist: keyring>=25.7.0
-Requires-Dist: tiktoken>=0.8.0
-Requires-Python: >=3.13
-Description-Content-Type: text/markdown
-
-# axe
-
-**The agent built for real codebases.**
-
-While other coding tools like claude code burn tokens on bloat to charge you more, axe gives you surgical precision. Built for large-scale projects, battle-tested internally for 6 months, and powered by the world's most advanced code retrieval engine.
-
----
-
-## What is axe?
-
-axe is an agent that runs in your terminal, helping you ship production code faster. It reads and edits code, executes shell commands, searches the web, and autonomously plans multi-step workflows—all while using **95% fewer tokens** than tools that dump your entire codebase into context.
-
-**Built for:**
-- **Real engineers** working on production systems with 100K+ line codebases
-- **Precision refactoring** where you need to understand call graphs before changing a function
-- **Debugging** that requires tracing data flow, not just reading error messages
-- **Architecture exploration** in unfamiliar codebases where grep won't cut it
-
-Hit **Ctrl+X** to toggle between axe and your normal shell. No context switching. No juggling terminals.
-/Users/rohit/proejct/axe-cli/assets/axe_gif_sample_Demo_zai.gif
-
-/Users/rohit/proejct/axe-cli/assets/axe_gif_axe_sample_toggle_shell.gif
----
-
-## Why axe exists
-
-**The problem:** Other tools dump your entire codebase into context, charging you for irrelevant noise. They're built for vibe coding—one-shot weekend projects where "good enough" is the goal.
-
-**The reality:** Real engineering happens in 100K+ line codebases where precision matters. You need to understand execution flow, trace bugs through call graphs, and refactor without breaking half your tests. You can't afford to burn 200K tokens reading files that don't matter.
-
-**The solution:** axe combines intelligent agents with **axe-dig**, our 5-layer code intelligence engine that extracts meaning instead of dumping text.
-
-### The axe-dig Advantage
-
-**Stop burning context windows. Start shipping features.**
-
-/Users/rohit/proejct/axe-cli/assets/axe_gif_init_axe.gif
-
-here you xan see how how call flow tracker works, both were able to find the context , but not only the right side axe dig impelmenation used 3 times less tokens overlal but it also found the call graphs for that decorator used on tracer functions, thread safe depth trakaicng but also was able to explain it much intuive becasue of its overall context about how the fucntion using this decorator work. unlike the one on the left qhih had to read the whole file after jsut grepping the call flow tracer literal strings to get the context using 44000 tokens compared to axe implemnatioons of 17k tokens.
-
-/Users/rohit/proejct/axe-cli/assets/axe_gif_explain_dig.gif
-
-Your codebase is 100,000 lines. Claude can read ~200,000 tokens. Math says you're already in trouble.
-
-| Approach | Tokens Used | What You Get |
-|----------|-------------|--------------|
-| Read raw files | 23,314 | Full code, zero context window left |
-| Grep results | ~5,000 | File paths. No understanding. |
-| **axe-dig** | **1,189** | Structure + call graph + complexity—everything needed to edit correctly |
-
-**95% token savings** while preserving the information LLMs actually need to write correct code.
-
-#### How axe-dig Works: we dig 5 levels deep.
-
-Not every question needs full program analysis. Pick the layer that matches your task:
-
-```
-┌─────────────────────────────────────────────────────────────┐
-│ Layer 5: Program Dependence  → "What affects line 42?"      │
-│ Layer 4: Data Flow           → "Where does this value go?"  │
-│ Layer 3: Control Flow        → "How complex is this?"       │
-│ Layer 2: Call Graph          → "Who calls this function?"   │
-│ Layer 1: AST                 → "What functions exist?"      │
-└─────────────────────────────────────────────────────────────┘
-```
-
-
-**Try it yourself on this codebase:**
-
-```bash
-# first run this if you didn't run the "axe" command prior to it. axe automicatlly makes the .dig folder with all the indexes, edges-- but since its your first time, you can run this first
-chop semantic index .
-
-# 1. Find code that resets counters (semantic search)
-chop semantic search "reset cumulative statistics and start fresh counter"
-
-# Result: Finds reset_step_count() at position #2 (score: 0.632)
-# Why this query? We're looking for state reset logic
-# What it found: TokenCounter.reset_step_count() - even though the code 
-# doesn't mention "cumulative" or "fresh", the embedding understands 
-# it resets a TokenCount object in a statistics tracking class
-
-# 2. Get token-efficient context
-chop context reset_step_count --project src/axe_cli/
-
-# Result: ~89 tokens (vs ~4,200 for reading the raw file)
-# Shows: Function signature, what it calls, complexity metrics
-# 98% token savings while preserving understanding
-
-# 3. Check who uses it before refactoring
-chop impact TokenCounter src/axe_cli/
-
-# Result: Only called by get_global_counter() in same file
-# Meaning: Safe to refactor - no external dependencies to break
-```
-
-**What this demonstrates:**
-- Semantic search finds code by behavior, not keywords
-- Context extraction gives you understanding at 2% of the token cost
-- Impact analysis shows dependencies instantly (no grep, no manual tracing)
-
-#### Semantic Search: Find Code by Behavior
-
-Here you can see how we took a sample cli agent with bas edit grep wrtie and shell on the left and on the right with axe as tools-- you will how much better it perfroms. for demo purposes we are showing a basic minimal. impelmenation of cli agents and also how even a simple agent with axe-dig tools jsut boost performance, and reduce token usage by lethacl precise search for large codebases. 
-
-/Users/rohit/proejct/axe-cli/assets/axe_gif_comparison.gif
-
-and then you will see the exponeential fall of llms wher eif they start wrong, they infer wrong, and as you can see i continued the conversation about callerinfromation and since the axe code implemenation on the right had more context and better understanding-- it was even more precise and lethal with followup questions. so not only axe optimsied for token savings-- it optimises for wha tthe code actually doies and how it flows:
-
-/Users/rohit/proejct/axe-cli/assets/axe_gif_Entire screen 2-1-2026 21-27-28.gif
-
-
-
-Traditional search finds syntax. axe-dig semantic search finds **what code does** based on call graphs and structure.
-
-```bash
-# Try this on the axe-cli codebase itself:
-chop semantic search "retry failed operations with exponential backoff"
-
-# Result: Finds _is_retryable_error() at position #1 (score: 0.713)
-# Why? The query doesn't mention "error" or specific function names
-# But the embedding understands retry logic patterns:
-# - Function checks exception types (retryable vs non-retryable)
-# - Called by retry loops with backoff logic
-# - Part of error handling flow in axesoul.py
-```
-
-**What it found:**
-```json
-[
-  {
-    "name": "_is_retryable_error",
-    "file": "src/axe_cli/soul/axesoul.py",
-    "score": 0.713
-  },
-  {
-    "name": "_retry_log",
-    "file": "src/axe_cli/soul/axesoul.py",
-    "score": 0.710
-  }
-]
-```
-
-**Another example: Find config loading**
-```bash
-chop semantic search "load configuration from toml file"
-
-# Result: load_config_from_string() at #1 (score: 0.759)
-# Finds TOML parsing, config migration, and related tests
-```
-
-Every function gets embedded with:
-- Signature + docstring
-- What it calls + who calls it (forward & backward call graph)
-- Complexity metrics (branches, loops, cyclomatic complexity)
-- Data flow (which variables are used, how they transform)
-- Dependencies (imports, external modules)
-- First ~10 lines of code
-
-This gets encoded into 1024-dimensional embeddings, so semantic search finds relevant code even when you use different terminology.
-
-#### Daemon Architecture: 300x Faster
-
-**The old way:** Every query spawns a new process, parses the entire codebase, throws away the results. ~30 seconds per query.
-
-**axe-dig's daemon:** Long-running background process with indexes in RAM. ~100ms per query.
-
-```bash
-# First query auto-starts daemon (transparent)
-axe  # In your project directory
-
-# Daemon stays running, queries use in-memory indexes
-# 100ms, not 30s per query
-```
-
-/Users/rohit/proejct/axe-cli/assets/axe_gif_sample_Demo_zai.gif
-
-
-**Incremental updates:** When you edit one function, axe-dig doesn't re-analyze the entire codebase. Content-hash-based caching with automatic dependency tracking means 10x faster incremental updates.
-
-**What's stored:** The daemon keeps call graphs, complexity metrics, and semantic embeddings in `.dig/cache/`. A typical project generates ~10MB of indexes that load into RAM in \u003c1 second. See [full cache structure](docs/AXE-DIG.md#cache-structure) for details.
-
-**[Read the full axe-dig documentation →](docs/AXE-DIG.md)**
-
----
-
-## Documentation Index
-
-We've organized the docs to make them digestible. Here's what's where:
-
-### [Common Use Cases & Workflows](examples/README.md)
-Learn how to use axe for implementing features, fixing bugs, understanding unfamiliar code, and automating tasks. Includes real workflow examples for debugging, refactoring, and exploration. See how axe handles everything from adding pagination to investigating race conditions.
-
-### [Built-in Tools](src/axe_cli/tools/README.md)
-Complete reference for all available tools: file operations, shell commands, multi-agent tasks, and the axe-dig code intelligence tools. CodeSearch finds code by behavior, CodeContext extracts LLM-ready summaries with 95% token savings, CodeStructure navigates files/directories, and CodeImpact shows reverse call graphs before you refactor. Every tool is designed for precision, not guesswork.
-
-### [Agent Skills](src/axe_cli/skills/README.md)
-How to create and use specialized skills to extend axe's capabilities. Skills are reusable workflows and domain expertise that you can invoke with `/skill:name` commands. Includes flow skills for multi-step automated workflows and examples for code style, git commits, and project standards. Turn your team's best practices into executable knowledge.
-
-### [Agents & Subagents](src/axe_cli/agents/README.md)
-Guide to creating custom agents and spawning specialized subagents for parallel work. Need a dedicated security researcher? A ruthlessly precise code reviewer? A creative copywriter? axe can create and deploy specialized subagents based on your exact requirements. These subagents operate with lethal precision to divide and conquer complex workflows.
-
-### [Technical Reference](src/axe_cli/README.md)
-Deep dive into configuration (providers, models, loop control), session management, architecture, and MCP integration. Everything you need to customize axe for your workflow. Configure Bodega models, set up OpenRouter/Anthropic/OpenAI providers, manage sessions, and integrate with other tools via Model Context Protocol.
-
-### [axe-dig: Code Intelligence Engine](docs/AXE-DIG.md)
-**The secret weapon.** Complete documentation on axe-dig's 5-layer architecture, semantic search, daemon mode, and program slicing. Learn how to extract 95% fewer tokens while preserving everything needed for correct edits. Includes performance benchmarks (155x faster queries, 89% token reduction), real-world debugging workflows, and the design rationale behind every choice. This is what makes axe different from every other coding tool.
-
----
-
-## Quick start
-
-### Install
-```bash
-# Install axe-cli (includes axe-dig)
-uv pip install axe-cli
-
-# Or from source
-git clone https://github.com/SRSWTI/axe-cli
-cd axe-cli
-make prepare
-make build
-
-or uv run axe
-```
-
-### Run
-```bash
-cd /path/to/your/project
-axe
-```
-
-On first run, axe-dig automatically indexes your codebase (30-60 seconds for typical projects). After that, queries are instant.
-
-### Start using
-```bash
-# Find code by behavior
-/skill:code-search "database connection pooling"
-
-# Understand a function without reading the whole file
-/skill:code-context get_user_by_id
-
-# See who calls a function before refactoring
-/skill:code-impact authenticate_request
-
-# Make surgical edits
-StrReplaceFile src/auth.py "old code" "new code"
-
-# Toggle to shell mode
-[Ctrl+X]
-pytest tests/
-[Ctrl+X]
-```
-
----
-
-## Core capabilities
-
-### Code intelligence (powered by axe-dig)
-
-| Tool | What it does | Use case |
-|------|-------------|----------|
-| **CodeSearch** | Semantic search by behavior | "Find payment processing logic" |
-| **CodeContext** | LLM-ready function summaries (95% token savings) | Understand unfamiliar code |
-| **CodeStructure** | Navigate functions/classes in files/dirs | Explore new codebases |
-| **CodeImpact** | Reverse call graph (who calls this?) | Safe refactoring |
-
-### File operations
-- `ReadFile` / `WriteFile` / `StrReplaceFile` - Standard file I/O
-- `Grep` - Exact file locations + line numbers (use after CodeSearch)
-- `Glob` - Pattern matching
-- `ReadMediaFile` - Images, PDFs, videos
-
-### Multi-agent workflows
-- `Task` - Spawn subagents for parallel work
-- `CreateSubagent` - Custom agent specs
-- `SetTodoList` - Track multi-step tasks
-
-### Shell integration
-- `Shell` - Execute commands
-- **Ctrl+X** - Toggle between axe and normal shell mode
-
----
-
-## Powered by SRSWTI Inc.
-
-**Building the world's fastest retrieval and inference engines.**
-
-### Bodega Inference Engine
-
-Exclusive models trained/optimized for Bodega Inference Engine. axe includes **zero-day support** for all Bodega models (ofcourse), ensuring immediate access to our latest breakthroughs.
-
-**Note:** Our models are also available on [🤗 Hugging Face](https://huggingface.co/srswti).
-
-#### Raptor Series
-Ultra-compact reasoning models designed for efficiency and edge deployment. **Super light**, amazing agentic coding capabilities, robust tool support, minimal memory footprint.
-
-- [🤗 **bodega-raptor-0.9b**](https://huggingface.co/srswti/bodega-raptor-0.9b) - 900M params. Runs on base m4 air with 100+ tok/s.
-- [🤗 **bodega-raptor-90m**](https://huggingface.co/srswti/bodega-raptor-90m) - Extreme edge variant. Sub-100M params for amazing tool calling.
-- [🤗 **bodega-raptor-1b-reasoning-opus4.5-distill**](https://huggingface.co/srswti/bodega-raptor-1b-reasoning-opus4.5-distill) - Distilled from Claude Opus 4.5 reasoning patterns.
-- [🤗 **bodega-raptor-8b-mxfp4**](https://huggingface.co/srswti/bodega-raptor-8b-mxfp4) - Balanced power/performance for laptops.
-- [🤗 **bodega-raptor-15b-6bit**](https://huggingface.co/srswti/bodega-raptor-15b-6bit) - Enhanced raptor variant.
-
-#### Flagship Models
-Frontier intelligence, distilled and optimized.
-
-- [🤗 **deepseek-v3.2-speciale-distilled-raptor-32b-4bit**](https://huggingface.co/srswti/deepseek-v3.2-speciale-distilled-raptor-32b-4bit) - DeepSeek V3.2 distilled to 32B with Raptor reasoning. Exceptional math/code generation in 5-7GB footprint. 120 tok/s on M1 Max.
-- [🤗 **bodega-centenario-21b-mxfp4**](https://huggingface.co/srswti/bodega-centenario-21b-mxfp4) - Production workhorse. 21B params optimized for sustained inference workloads.
-- [🤗 **bodega-solomon-9b**](https://huggingface.co/srswti/bodega-solomon-9b) - Multimodal and best for agentic coding.
-
-#### Axe-Turbo Series
-**Launched specifically for the Axe coding use case.** High-performance agentic coding models optimized for the Axe ecosystem.
-
-- [🤗 **axe-turbo-1b**](https://huggingface.co/srswti/axe-turbo-1b) - 1B params, 150 tok/s, sub-50ms first token. Edge-first architecture.
-- [🤗 **axe-turbo-31b**](https://huggingface.co/srswti/axe-turbo-31b) - High-capacity workloads. Exceptional agentic capabilities.
-
-#### Specialized Models
-Task-specific optimization.
-
-- [🤗 **bodega-vertex-4b**](https://huggingface.co/srswti/bodega-vertex-4b) - 4B params. Optimized for structured data.
-- [🤗 **blackbird-she-doesnt-refuse-21b**](https://huggingface.co/srswti/blackbird-she-doesnt-refuse-21b) - Uncensored 21B variant for unrestricted generation.
-
-### Using Bodega Models
-
-Configure Bodega in `~/.axe/config.toml`:
-
-```toml
-default_model = "bodega-raptor"
-
-[providers.bodega]
-type = "bodega"
-base_url = "http://localhost:44468"  # Local Bodega server
-api_key = ""
-
-[models.bodega-raptor]
-provider = "bodega"
-model = "srswti/bodega-raptor-8b-mxfp4"
-max_context_size = 32768
-capabilities = ["thinking"]
-
-[models.bodega-turbo]
-provider = "bodega"
-model = "srswti/axe-turbo-31b"
-max_context_size = 32768
-capabilities = ["thinking"]
-```
-
-See [sample_config.toml](sample_config.toml) for more examples including OpenRouter, Anthropic, and OpenAI configurations.
-
----
-
-## What's coming
-
-Our internal team has been using features that will change the game:
-
-### 1. Execution Tracing
-See what actually happened at runtime. No more guessing why a test failed.
-
-```bash
-# Trace a failing test
-/trace pytest tests/test_payment.py::test_refund
-
-# Shows exact values that flowed through each function:
-# process_refund(amount=Decimal("50.00"), transaction_id="tx_123")
-#   → validate_refund(transaction=Transaction(status="completed"))
-#     → check_refund_window(created_at=datetime(2024, 1, 15))
-#       → datetime.now() - created_at = timedelta(days=45)
-#       → raised RefundWindowExpired  # ← 30-day window exceeded
-```
-
-### 2. Performance Debugging
-Flame graphs and memory profiling integrated directly in the chat interface.
-
-```bash
-# Generate flame graph
-/flamegraph api_server.py
-
-# Find memory leaks
-/memory-profile background_worker.py
-```
-
-### 3. Visual Debugging
-Interactive visualizations for understanding complex codebases:
-
-- **Call graphs**: See the entire call chain from entry point to implementation
-- **Dependency graphs**: Understand module relationships and coupling
-- **AST visualizations**: Navigate code structure visually
-- **Data flow diagrams**: Trace how values transform through your system
-
-All generated on demand and viewable in your browser. No more drawing diagrams on whiteboards—axe-dig generates them from your actual code.
-
-### 4. Smart Test Selection
-```bash
-# Only run tests affected by your changes
-/test-impact src/payment/processor.py
-
-# Shows: 12 tests need to run (not all 1,847)
-```
-
----
-
-## Why we built this
-
-We're building the world's best retrieval and inference engine. We started with coding because it's the hardest problem: understanding large codebases, tracing execution, debugging logic errors, optimizing performance.
-
-If we can nail code understanding, we can nail anything.
-
-**This is not for vibe coders.** This is not for weekend hackathons where "it works on my machine" is good enough. This is for engineers shipping production code to real users, where bugs cost money and downtime costs more.
-
-Other tools optimize for demo videos and charging per token. We optimize for engineers who need to:
-- Refactor 10,000 lines without breaking tests
-- Debug race conditions in distributed systems
-- Understand legacy codebases with zero documentation
-- Ship features on deadline without cutting corners
-
-**The bottom line:** If you're building real software in large codebases, you need precision tools. Not vibe coding toys.
-
-Welcome to axe.
-
----
-
-## Supported languages
-
-Python, TypeScript, JavaScript, Go, Rust, Java, C, C++, Ruby, PHP, C#, Kotlin, Scala, Swift, Lua, Elixir
-
-Language auto-detected. Specify with `--lang` if needed.
-
----
-
-## Comparison
-
-| Feature | Claude Code | OpenAI Codex | axe |
-|---------|-------------|--------------|-----|
-| **Built for** | Weekend projects | Demos | Production codebases |
-| **Context strategy** | Dump everything | Dump everything | Extract signal (95% savings) |
-| **Code search** | Text/regex | Text/regex | Semantic (behavior-based) |
-| **Call graph analysis** | ❌ | ❌ | ✅ 5-layer analysis |
-| **Token optimization** | ❌ (incentivized to waste) | ❌ (incentivized to waste) | ✅ Show savings per query |
-| **Execution tracing** | ❌ | ❌ | ✅ Coming soon |
-| **Flame graphs** | ❌ | ❌ | ✅ Coming soon |
-| **Memory profiling** | ❌ | ❌ | ✅ Coming soon |
-| **Visual debugging** | ❌ | ❌ | ✅ Coming soon |
-| **Shell integration** | ❌ | ❌ | ✅ Ctrl+X toggle |
-| **Session management** | Limited | Limited | ✅ Full history + replay |
-| **Skills system** | ❌ | ❌ | ✅ Modular, extensible |
-| **Subagents** | ❌ | ❌ | ✅ Parallel task execution |
-| **Battle-tested** | Public beta | Public API | 6 months internal use |
-
----
-
-## Community
-
-- **Issues**: [GitHub Issues](https://github.com/SRSWTI/axe-cli/issues)
-- **Discussions**: [GitHub Discussions](https://github.com/SRSWTI/axe-cli/discussions)
-- **Docs**: [Full documentation](https://axe-cli.dev/docs)
-
-## Acknowledgements
-
-Special thanks to [MoonshotAI/kimi-cli](https://github.com/MoonshotAI/kimi-cli) for their amazing work, which inspired our tools and the Kosong provider.