# 🍞 Breadcrumb: Automatic Execution Tracing
**Breadcrumb lets you do this:**
```bash
# Run your code with automatic tracing (NO code changes needed!)
breadcrumb run -c myproject --timeout 60 python my_code.py
```
**Output:**
```bash
============================================================
BREADCRUMB RUN REPORT
============================================================
Key Metrics:
Total Events: 22
- Calls: 9
- Returns: 9
- Exceptions: 0
Duration: 4.06 ms
Status: completed
Call Tree:
-> __main__.<module>
-> __main__.main
-> __main__.add
<- __main__.add (0.05ms)
-> __main__.multiply
<- __main__.multiply (0.05ms)
-> __main__.greet
<- __main__.greet (0.04ms)
-> __main__.calculate_total
-> __main__.multiply
<- __main__.multiply (0.08ms)
-> __main__.multiply
<- __main__.multiply (0.08ms)
-> __main__.add
<- __main__.add (0.04ms)
<- __main__.calculate_total (0.51ms)
<- __main__.main (1.46ms)
<- __main__.<module> (1.61ms)
Top 10 Most Called Functions:
__main__.multiply: 3 calls
__main__.add: 2 calls
__main__.greet: 1 calls
__main__.<module>: 1 calls
__main__.main: 1 calls
__main__.calculate_total: 1 calls
Recommendations on what to do next:
Detailed Flow: breadcrumb query -c example01 --flow
Untraced calls: breadcrumb query -c example01 --gaps
View specific call: breadcrumb query -c example01 --call <call_id>
Example 'multiply': breadcrumb query -c example01 --call multiply
```
**Dig in:**
```bash
# Query critical debug information: Called by, calls made, performance stats, input args, return values
breadcrumb query -c example01 --call multiply
```
**Output:**
```json
{
"function": "__main__.multiply",
"calls": [
{
"function": "__main__.multiply",
"timestamp": "2025-10-11T22:50:39.444263",
"args": {
"a": 7,
"b": 6
},
"return_value": 42,
"duration_ms": 0.049,
"called_by": "__main__.main",
"calls_made": []
},
{
"function": "__main__.multiply",
"timestamp": "2025-10-11T22:50:39.444732",
"args": {
"a": 100,
"b": 2
},
"return_value": 200,
"duration_ms": 0.082,
"called_by": "__main__.calculate_total",
"calls_made": []
},
{
"function": "__main__.multiply",
"timestamp": "2025-10-11T22:50:39.444900",
"args": {
"a": 200,
"b": 0.15
},
"return_value": 30.0,
"duration_ms": 0.083,
"called_by": "__main__.calculate_total",
"calls_made": []
}
]
}
```
```bash
# Find out what was called by traced calls that isn't yet traced by breadcrumb
breadcrumb query -c example01 --gaps
```
**Output:**
```json
{
"untraced_calls": [
{
"function": "json.dumps",
"module": "json",
"called_by": "__main__.format_response",
"call_count": 3,
"suggested_include": "json.*"
},
{
"function": "requests.post",
"module": "requests",
"called_by": "__main__.send_webhook",
"call_count": 1,
"suggested_include": "requests.*"
}
],
"tip": "Add these to your config to trace them:\n breadcrumb config edit myapp --add-include 'json.*'\n breadcrumb config edit myapp --add-include 'requests.*'"
}
```
**Expand tracing and re-run:**
```bash
# include untraced calls
breadcrumb config edit --add-include 'requests.*'
# run again
breadcrumb run python my_code.py
breadcrumb query --call post
```
**Output:**
```json
{
"function": "requests.post",
"calls": [
{
"timestamp": "2025-10-11T15:30:42.123",
"args": {"url": "https://api.example.com/webhook", "data": {"event": "user.signup"}},
"return_value": {"status": 200, "body": "OK"},
"duration_ms": 234.5,
"called_by": "__main__.send_webhook",
"calls_made": ["json.dumps"]
}
]
}
```
---
## Why Would You Need This?
**You probably won't. But your AI coding agent will LOVE this.**
### The Problem: AI Agents Can't "Step Through" Code
When humans debug, we:
- Set breakpoints and step through execution
- Watch variables change in real-time
- See the actual call stack in our debugger
- Understand what the code *actually did* vs what we *thought* it would do
When AI agents debug, they:
- ❌ Can't set breakpoints (no interactive debugger access)
- ❌ Can't "watch" execution (no real-time visibility)
- ❌ Can't inspect the call stack (no execution context)
- ❌ Must **guess** what happened by reading static code
**Result:** AI agents spend 80% of debugging time making guesses, reading logs, and asking "what actually ran?"
### The Solution: Breadcrumb = X-Ray Vision for AI Agents
Breadcrumb captures **what actually happened** during execution:
- ✅ **Every function call** with arguments and return values
- ✅ **Exact execution flow** in chronological order
- ✅ **Gaps in coverage** showing untraced function calls
- ✅ **Call relationships** (who called what)
- ✅ **Performance data** (execution duration)
**No code changes. No manual logging. No guessing.**
Just run your code with `breadcrumb run` and query the execution trace with structured commands.
---
## Codex CLI using breadcrumb
```bash
# Prompt
By running 'breadcrumb', present a table showing how long each mathematical function call in the example took.
```
<p align="center">
<img alt="codex" src="https://raw.githubusercontent.com/AndreRatzenberger/breadcrumb-tracer/main/docs/assets/img/codex_small.png?token=GHSAT0AAAAAADM23FLU3N4KFYFYZTLGL3HQ2HK4HGQ" width="1000">
</p>
## Codex CLI using advanced queries for complex tasks
<p align="center">
<img alt="codex" src="https://raw.githubusercontent.com/AndreRatzenberger/breadcrumb-tracer/main/docs/assets/img/complex_2.png?token=GHSAT0AAAAAADM23FLVPK2W74UWYKQJTRAK2HK4HIA" width="1000">
</p>
## Key Features
### 🎯 Gap Detection
**Problem:** You can't trace EVERYTHING (performance overhead). So what aren't you tracing?
**Solution:** `breadcrumb query --gaps` shows you exactly which functions were called but not traced.
```bash
breadcrumb query -c myapp --gaps
# Shows: requests.post called 5 times by myapp.api_client
# Suggests: breadcrumb config edit myapp --add-include 'requests.*'
```
**Workflow:** Start minimal → discover gaps → expand tracing → repeat
This is **iterative debugging** - trace only what you need, when you need it.
### 🤖 AI-FIRST Design
**Traditional tools:** Optimize for human convenience (implicit context, smart defaults)
**Breadcrumb:** Optimizes for AI reliability (explicit context, zero ambiguity)
```bash
# ❌ IMPLICIT (confusing for AI agents)
breadcrumb run python script.py # Which database? Which config?
breadcrumb query --gaps # Where are the traces?
# ✅ EXPLICIT (perfect for AI agents)
breadcrumb run -c myapp python script.py # Clear: using myapp config
breadcrumb query -c myapp --gaps # Clear: querying myapp database
```
**Result:** Zero context confusion across sessions. AI agents can resume debugging workflows perfectly.
### 📊 Smart Queries (No SQL Required)
AI agents don't need to learn SQL. They just need structured data.
```bash
# Find untraced calls
breadcrumb query -c myapp --gaps
# Show function I/O
breadcrumb query -c myapp --call send_webhook
# Show execution timeline
breadcrumb query -c myapp --flow
# Filter by module
breadcrumb query -c myapp --flow --module myapp
# Search captured events for a literal string (function names, args, payloads, etc.)
breadcrumb query -c myapp --fuzzy breadcrumbs
```
All output is structured JSON, ready for AI consumption.
Call queries accept substrings, so `breadcrumb query -c myapp --call Pizza` resolves to
`__main__.Pizza` (and its `__init__`) and `breadcrumb query -c myapp --call "__main__."`
returns every function in `__main__`. Constructors capture their keyword arguments and
return values automatically, making object creation auditable without extra logging.
Need a human-readable table? Switch formats:
```bash
# Table output with full values preserved for wide SQL results
breadcrumb --format table query -c myapp --disable-truncation \
"SELECT function_name, data FROM trace_events ORDER BY timestamp DESC LIMIT 5"
# Increase captured payload size when recording new traces (default 2000 chars)
breadcrumb run -c myapp -t 60 --max-chars 5000 python main.py
```
### 🚫 Zero Code Changes
```bash
# ✅ Just run with breadcrumb
breadcrumb run -c myapp --timeout 60 python main.py
# NO code modifications needed!
```
Your codebase stays clean. Tracing is external.
### 🔒 Automatic Secret Redaction
Breadcrumb automatically detects and redacts 50+ sensitive patterns:
- Passwords, API keys, tokens
- Credit cards, SSNs
- JWTs, AWS keys, GitHub tokens
```python
data = {"api_key": "sk-1234567890", "password": "secret"}
# Stored as: {"api_key": "[REDACTED]", "password": "[REDACTED]"}
```
**Safe for production traces.**
### ⚡ Low Overhead
- **PEP 669 backend** (Python 3.12+): < 2% overhead
- **sys.settrace backend** (Python 3.8+): < 5% overhead
- **Selective tracing**: Only trace what you need
- **Async writes**: Non-blocking trace persistence
---
## Quick Start
### Installation
```bash
# Using uv (recommended)
uv pip install -e .
# Or using pip
pip install -e .
```
### The Complete Workflow
**1️⃣ Initialize your project (one-time setup):**
```bash
breadcrumb init myapp
```
Creates:
- `~/.breadcrumb/myapp.yaml` (config with sensible defaults)
- `~/.breadcrumb/myapp-traces.duckdb` (trace database)
**2️⃣ Run your code with tracing:**
```bash
breadcrumb run -c myapp --timeout 60 python main.py
```
Automatically traces execution. NO code changes needed.
**3️⃣ Find gaps in coverage:**
```bash
breadcrumb query -c myapp --gaps
```
Shows which functions were called but not traced.
**4️⃣ Expand tracing based on gaps:**
```bash
breadcrumb config edit myapp --add-include 'requests.*'
breadcrumb config edit myapp --add-include 'sqlalchemy.*'
```
**5️⃣ Re-run with expanded tracing:**
```bash
breadcrumb run -c myapp --timeout 60 python main.py
```
Now traces additional modules!
**6️⃣ Query function details:**
```bash
breadcrumb query -c myapp --call my_function
breadcrumb query -c myapp --call "__main__." # Substring match, includes constructors
```
Shows args, returns, duration, caller/callee relationships.
**7️⃣ View execution timeline:**
```bash
breadcrumb query -c myapp --flow
```
Shows chronological execution order with call stack depth.
**8️⃣ (Optional) Capture richer payloads:**
```bash
breadcrumb run -c myapp --timeout 60 --max-chars 5000 python main.py
```
Increases argument/return capture size without touching your source code.
---
## AI-FIRST Design Philosophy
### Why `-c PROJECT` is REQUIRED
**All commands require explicit project specification:**
```bash
breadcrumb run -c myapp python script.py # REQUIRED
breadcrumb query -c myapp --gaps # REQUIRED
breadcrumb config edit myapp --add-include 'x' # REQUIRED
```
**This eliminates:**
- ❌ "Which database am I querying?"
- ❌ "Which config is active?"
- ❌ "Where did my traces go?"
- ❌ Context loss between AI agent sessions
**Why it matters:**
- **Humans:** "Ugh, typing `-c myapp` every time is annoying!"
- **AI Agents:** "Perfect! No ambiguity, no context confusion!"
**Design philosophy:** Explicit > Implicit for AI workflows.
AI agents don't care about typing extra characters. They care about reliability across sessions.
---
## Command Reference
### Core Commands
```bash
# Initialize project
breadcrumb init <project-name>
# Run with tracing
breadcrumb run -c <project> --timeout <seconds> <command>
# Smart queries
breadcrumb query -c <project> --gaps # Find untraced calls
breadcrumb query -c <project> --call <func> # Show function I/O
breadcrumb query -c <project> --flow # Show execution timeline
# Inspect recorded traces
breadcrumb list -c <project>
breadcrumb get -c <project> <trace_id>
breadcrumb report -c <project>
breadcrumb top -c <project> 20
breadcrumb exceptions -c <project> --since 2h
breadcrumb clear -c <project> --force
# Config management
breadcrumb config create <name>
breadcrumb config edit <name> --add-include <pattern>
breadcrumb config edit <name> --remove-include <pattern>
breadcrumb config show <name>
breadcrumb config list
```
### Query Examples
```bash
# Find what's not traced
breadcrumb query -c myapp --gaps
# Show function with args/returns
breadcrumb query -c myapp --call process_payment
# Show execution flow for module
breadcrumb query -c myapp --flow --module myapp
# Substring call search (returns constructors too)
breadcrumb query -c myapp --call "__main__." # All __main__ functions
breadcrumb query -c myapp --call Pizza # Matches __main__.Pizza/__init__
# Raw SQL query (still supported)
breadcrumb query -c myapp --sql "SELECT * FROM traces WHERE status='failed'"
```
### Config Examples
```bash
# Start with minimal tracing
breadcrumb init myapp
# Creates config with include: ['__main__']
# Expand based on gaps
breadcrumb config edit myapp --add-include 'requests.*'
breadcrumb config edit myapp --add-include 'sqlalchemy.*'
breadcrumb config edit myapp --add-include 'myapp.services.*'
# Remove noisy modules
breadcrumb config edit myapp --remove-include 'logging.*'
# View current config
breadcrumb config show myapp
```
---
## Use Cases for AI Coding Agents
### 1. Understanding Legacy Code
**Human approach:**
- Read docs (if they exist)
- Step through with debugger
- Ask teammates
**AI agent approach:**
```bash
# Run the code
breadcrumb run -c legacy --timeout 120 python legacy_system.py
# See what actually executed
breadcrumb query -c legacy --flow
# Find entry points
breadcrumb query -c legacy --gaps
```
**Result:** AI agent sees actual execution flow, not just static code.
### 2. Debugging API Integration Issues
**Human approach:**
- Add print statements
- Check API logs
- Use network inspector
**AI agent approach:**
```bash
# Trace the integration
breadcrumb config edit myapp --add-include 'requests.*'
breadcrumb run -c myapp --timeout 60 python test_api.py
# See exact API calls
breadcrumb query -c myapp --call 'requests.post'
```
**Result:** AI agent sees exact request args, response values, and timing.
### 3. Performance Investigation
**Human approach:**
- Use profiler
- Add timing code
- Analyze bottlenecks
**AI agent approach:**
```bash
# Run with tracing
breadcrumb run -c myapp --timeout 300 python load_test.py
# Find slow functions
breadcrumb query -c myapp --sql "SELECT function_name, AVG(duration_ms) FROM trace_events GROUP BY function_name ORDER BY AVG(duration_ms) DESC LIMIT 10"
```
**Result:** AI agent identifies performance bottlenecks from real execution data.
### 4. Test Failure Analysis
**Human approach:**
- Re-run test
- Add debug output
- Check assertions
**AI agent approach:**
```bash
# Run failing test with tracing
breadcrumb run -c tests --timeout 60 pytest tests/test_payment.py::test_refund
# See what actually happened
breadcrumb query -c tests --call process_refund
# Check execution flow
breadcrumb query -c tests --flow --module myapp.payments
```
**Result:** AI agent sees exact execution path that led to failure.
---
## MCP Integration (Claude Desktop)
Breadcrumb includes an MCP server for Claude Desktop integration.
**Setup:**
Add to `claude_desktop_config.json`:
```json
{
"mcpServers": {
"breadcrumb": {
"command": "breadcrumb",
"args": ["serve-mcp"],
"env": {}
}
}
}
```
**Available Tools:**
- `breadcrumb__query_traces` - Execute SQL queries
- `breadcrumb__get_trace` - Get trace details by ID
- `breadcrumb__find_exceptions` - Find exceptions in traces
- `breadcrumb__analyze_performance` - Analyze function performance
**Usage:**
```
Tell Claude: "Use breadcrumb to find the last exception in my app"
Claude will use: breadcrumb__find_exceptions
```
---
## Advanced Configuration
### Python API (Optional)
If you need programmatic control, you can still use the Python API:
```python
import breadcrumb
# Basic configuration
breadcrumb.init(
enabled=True,
sample_rate=1.0,
db_path="~/.breadcrumb/myapp-traces.duckdb",
include=["myapp.*", "requests.*"]
)
# Your code here
def my_function():
pass
```
**But 99% of use cases should use `breadcrumb run` instead.**
### Environment Variables
```bash
# Override config settings
export BREADCRUMB_ENABLED=true
export BREADCRUMB_DB_PATH="/custom/path/traces.duckdb"
export BREADCRUMB_SAMPLE_RATE=0.5
```
---
## Database Schema
Breadcrumb stores traces in DuckDB with these tables:
**traces** - One row per execution:
```sql
CREATE TABLE traces (
id VARCHAR PRIMARY KEY,
started_at TIMESTAMP,
ended_at TIMESTAMP,
status VARCHAR, -- 'running', 'completed', 'failed'
duration_ms DOUBLE
);
```
**trace_events** - Function calls and returns:
```sql
CREATE TABLE trace_events (
id VARCHAR PRIMARY KEY,
trace_id VARCHAR,
timestamp TIMESTAMP,
event_type VARCHAR, -- 'call', 'return', 'exception', 'call_site'
function_name VARCHAR,
module_name VARCHAR,
data JSON -- Contains: args, kwargs, return_value, caller info
);
```
**Direct SQL access:**
```python
import duckdb
conn = duckdb.connect('~/.breadcrumb/myapp-traces.duckdb')
result = conn.execute("SELECT * FROM traces").fetchall()
```
---
## How It Works
### Architecture
1. **PEP 669 Backend (Python 3.12+)**
- Uses sys.monitoring API (low overhead)
- Captures function calls/returns automatically
- Detects untraced calls for gap detection
2. **Trace Storage (DuckDB)**
- Fast columnar database
- JSON support for flexible data
- SQL queryable for complex analysis
3. **Smart Query Layer**
- Abstracts SQL complexity
- Returns structured JSON
- Optimized for AI agent consumption
4. **CLI Interface**
- Typer-based commands
- Explicit project specification
- AI-FIRST design principles
### Include-Only Workflow
**Default behavior:** Trace only `__main__` module (minimal overhead)
**Iterative expansion:**
```bash
breadcrumb run -c myapp python script.py # Trace __main__ only
breadcrumb query -c myapp --gaps # Find what's not traced
breadcrumb config edit myapp --add-include 'requests.*' # Expand
breadcrumb run -c myapp python script.py # Trace more
```
**Philosophy:** Start minimal, expand based on what you discover.
This is **much better** than tracing everything and filtering later.
---
## Performance
Breadcrumb is designed for production use:
**Overhead benchmarks (1M function calls):**
- Baseline: 0.85s
- With Breadcrumb (PEP 669): 0.87s (2.4% overhead)
- With Breadcrumb (settrace): 0.89s (4.7% overhead)
**Optimization strategies:**
- Selective tracing (include patterns)
- Async database writes
- Value truncation (prevent bloat)
- Smart sampling (optional)
---
## Security
**Automatic secret redaction** prevents sensitive data from reaching traces:
**Detected patterns:**
- Password fields (`password`, `passwd`, `pwd`, `secret`)
- API keys (`api_key`, `apikey`, `token`, `bearer`)
- Credit cards (16-digit patterns)
- SSNs (XXX-XX-XXXX format)
- JWTs (eyJ... tokens)
- AWS keys (AKIA... patterns)
- GitHub tokens (ghp_... patterns)
**Custom patterns:**
```python
from breadcrumb.capture.secret_redactor import configure_redactor
configure_redactor(custom_patterns=['my_secret_*', 'internal_token'])
```
---
## Requirements
- **Python 3.12+** (recommended for PEP 669 backend)
- **Python 3.10+** (falls back to sys.settrace backend)
- **DuckDB 1.4.1+**
- **FastMCP 2.12.4+** (for MCP server)
- **Typer 0.19.2+** (for CLI)
---
## Status
**Current version:** 0.2.0 (Beta)
**Production-ready features:**
- ✅ PEP 669 tracing backend
- ✅ Zero-code-change execution (`breadcrumb run`)
- ✅ Gap detection (`--gaps` command)
- ✅ Smart queries (no SQL needed)
- ✅ AI-FIRST design (explicit `-c` everywhere)
- ✅ Automatic secret redaction
- ✅ DuckDB storage
- ✅ MCP server integration
**Coming soon:**
- 🚧 `--call` command (show function I/O details)
- 🚧 `--flow` command (execution timeline)
- 📦 PyPI package
- 📊 Performance visualizations
- ☁️ Cloud storage backends
---
## Contributing
We welcome contributions! This project is built for AI coding agents.
**Development setup:**
```bash
git clone https://github.com/AndreRatzenberger/breadcrumb-tracer.git
cd breadcrumb-tracer
uv pip install -e .
pytest tests/
```
**Key principles:**
- AI-FIRST design (explicit over implicit)
- Zero code changes required
- Performance matters (< 5% overhead)
- Test-driven development
---
## License
MIT License - see LICENSE file for details.
---
## Acknowledgments
Built with:
- [PEP 669 (sys.monitoring)](https://peps.python.org/pep-0669/) - Low-overhead monitoring API
- [DuckDB](https://duckdb.org/) - Embedded analytical database
- [FastMCP](https://github.com/jlowin/fastmcp) - MCP server framework
- [Typer](https://typer.tiangolo.com/) - CLI framework
Special thanks to the Model Context Protocol team at Anthropic for enabling AI-native tooling.
---
## The Bottom Line
**Humans debug with debuggers.**
**AI agents debug with execution traces.**
Breadcrumb gives AI coding agents the X-ray vision they need to understand what your code actually does - not just what it's supposed to do.
No code changes. No manual logging. No guessing.
Just structured execution data, queryable in real-time.
**That's Breadcrumb.** 🍞
Raw data
{
"_id": null,
"home_page": null,
"name": "breadcrumb",
"maintainer": null,
"docs_url": null,
"requires_python": ">=3.10",
"maintainer_email": null,
"keywords": "ai, claude, debugging, execution-tracer, instrumentation, llm, mcp, observability, profiling, tracing",
"author": "Breadcrumb Contributors",
"author_email": null,
"download_url": "https://files.pythonhosted.org/packages/34/41/a8ef09d200f3f41eaaaf0f89ce37f97ee7bd69829182a6ad2088db6b6959/breadcrumb-0.2.13.tar.gz",
"platform": null,
"description": "# \ud83c\udf5e Breadcrumb: Automatic Execution Tracing\n\n**Breadcrumb lets you do this:**\n\n```bash\n# Run your code with automatic tracing (NO code changes needed!)\nbreadcrumb run -c myproject --timeout 60 python my_code.py\n```\n\n**Output:**\n```bash\n============================================================\nBREADCRUMB RUN REPORT\n============================================================\n\nKey Metrics:\n Total Events: 22\n - Calls: 9\n - Returns: 9\n - Exceptions: 0\n Duration: 4.06 ms\n Status: completed\n\nCall Tree:\n-> __main__.<module>\n -> __main__.main\n -> __main__.add\n <- __main__.add (0.05ms)\n -> __main__.multiply\n <- __main__.multiply (0.05ms)\n -> __main__.greet\n <- __main__.greet (0.04ms)\n -> __main__.calculate_total\n -> __main__.multiply\n <- __main__.multiply (0.08ms)\n -> __main__.multiply\n <- __main__.multiply (0.08ms)\n -> __main__.add\n <- __main__.add (0.04ms)\n <- __main__.calculate_total (0.51ms)\n <- __main__.main (1.46ms)\n<- __main__.<module> (1.61ms)\n\nTop 10 Most Called Functions:\n __main__.multiply: 3 calls\n __main__.add: 2 calls\n __main__.greet: 1 calls\n __main__.<module>: 1 calls\n __main__.main: 1 calls\n __main__.calculate_total: 1 calls\n\nRecommendations on what to do next:\n Detailed Flow: breadcrumb query -c example01 --flow\n Untraced calls: breadcrumb query -c example01 --gaps\n View specific call: breadcrumb query -c example01 --call <call_id>\n Example 'multiply': breadcrumb query -c example01 --call multiply\n\n```\n\n**Dig in:**\n```bash\n# Query critical debug information: Called by, calls made, performance stats, input args, return values\nbreadcrumb query -c example01 --call multiply\n```\n\n**Output:**\n```json\n{\n \"function\": \"__main__.multiply\",\n \"calls\": [\n {\n \"function\": \"__main__.multiply\",\n \"timestamp\": \"2025-10-11T22:50:39.444263\",\n \"args\": {\n \"a\": 7,\n \"b\": 6\n },\n \"return_value\": 42,\n \"duration_ms\": 0.049,\n \"called_by\": \"__main__.main\",\n \"calls_made\": []\n },\n {\n \"function\": \"__main__.multiply\",\n \"timestamp\": \"2025-10-11T22:50:39.444732\",\n \"args\": {\n \"a\": 100,\n \"b\": 2\n },\n \"return_value\": 200,\n \"duration_ms\": 0.082,\n \"called_by\": \"__main__.calculate_total\",\n \"calls_made\": []\n },\n {\n \"function\": \"__main__.multiply\",\n \"timestamp\": \"2025-10-11T22:50:39.444900\",\n \"args\": {\n \"a\": 200,\n \"b\": 0.15\n },\n \"return_value\": 30.0,\n \"duration_ms\": 0.083,\n \"called_by\": \"__main__.calculate_total\",\n \"calls_made\": []\n }\n ]\n}\n```\n\n```bash\n# Find out what was called by traced calls that isn't yet traced by breadcrumb\nbreadcrumb query -c example01 --gaps\n```\n\n**Output:**\n```json\n{\n \"untraced_calls\": [\n {\n \"function\": \"json.dumps\",\n \"module\": \"json\",\n \"called_by\": \"__main__.format_response\",\n \"call_count\": 3,\n \"suggested_include\": \"json.*\"\n },\n {\n \"function\": \"requests.post\",\n \"module\": \"requests\",\n \"called_by\": \"__main__.send_webhook\",\n \"call_count\": 1,\n \"suggested_include\": \"requests.*\"\n }\n ],\n \"tip\": \"Add these to your config to trace them:\\n breadcrumb config edit myapp --add-include 'json.*'\\n breadcrumb config edit myapp --add-include 'requests.*'\"\n}\n```\n\n**Expand tracing and re-run:**\n```bash\n# include untraced calls\nbreadcrumb config edit --add-include 'requests.*'\n# run again\nbreadcrumb run python my_code.py\nbreadcrumb query --call post\n```\n\n**Output:**\n```json\n{\n \"function\": \"requests.post\",\n \"calls\": [\n {\n \"timestamp\": \"2025-10-11T15:30:42.123\",\n \"args\": {\"url\": \"https://api.example.com/webhook\", \"data\": {\"event\": \"user.signup\"}},\n \"return_value\": {\"status\": 200, \"body\": \"OK\"},\n \"duration_ms\": 234.5,\n \"called_by\": \"__main__.send_webhook\",\n \"calls_made\": [\"json.dumps\"]\n }\n ]\n}\n```\n---\n\n## Why Would You Need This?\n\n**You probably won't. But your AI coding agent will LOVE this.**\n\n### The Problem: AI Agents Can't \"Step Through\" Code\n\nWhen humans debug, we:\n- Set breakpoints and step through execution\n- Watch variables change in real-time\n- See the actual call stack in our debugger\n- Understand what the code *actually did* vs what we *thought* it would do\n\nWhen AI agents debug, they:\n- \u274c Can't set breakpoints (no interactive debugger access)\n- \u274c Can't \"watch\" execution (no real-time visibility)\n- \u274c Can't inspect the call stack (no execution context)\n- \u274c Must **guess** what happened by reading static code\n\n**Result:** AI agents spend 80% of debugging time making guesses, reading logs, and asking \"what actually ran?\"\n\n### The Solution: Breadcrumb = X-Ray Vision for AI Agents\n\nBreadcrumb captures **what actually happened** during execution:\n- \u2705 **Every function call** with arguments and return values\n- \u2705 **Exact execution flow** in chronological order\n- \u2705 **Gaps in coverage** showing untraced function calls\n- \u2705 **Call relationships** (who called what)\n- \u2705 **Performance data** (execution duration)\n\n**No code changes. No manual logging. No guessing.**\n\nJust run your code with `breadcrumb run` and query the execution trace with structured commands.\n\n---\n\n## Codex CLI using breadcrumb\n\n```bash\n# Prompt\nBy running 'breadcrumb', present a table showing how long each mathematical function call in the example took.\n```\n\n<p align=\"center\">\n <img alt=\"codex\" src=\"https://raw.githubusercontent.com/AndreRatzenberger/breadcrumb-tracer/main/docs/assets/img/codex_small.png?token=GHSAT0AAAAAADM23FLU3N4KFYFYZTLGL3HQ2HK4HGQ\" width=\"1000\">\n</p>\n\n\n## Codex CLI using advanced queries for complex tasks\n\n<p align=\"center\">\n <img alt=\"codex\" src=\"https://raw.githubusercontent.com/AndreRatzenberger/breadcrumb-tracer/main/docs/assets/img/complex_2.png?token=GHSAT0AAAAAADM23FLVPK2W74UWYKQJTRAK2HK4HIA\" width=\"1000\">\n</p>\n\n\n\n\n## Key Features\n\n### \ud83c\udfaf Gap Detection\n\n**Problem:** You can't trace EVERYTHING (performance overhead). So what aren't you tracing?\n\n**Solution:** `breadcrumb query --gaps` shows you exactly which functions were called but not traced.\n\n```bash\nbreadcrumb query -c myapp --gaps\n# Shows: requests.post called 5 times by myapp.api_client\n# Suggests: breadcrumb config edit myapp --add-include 'requests.*'\n```\n\n**Workflow:** Start minimal \u2192 discover gaps \u2192 expand tracing \u2192 repeat\n\nThis is **iterative debugging** - trace only what you need, when you need it.\n\n### \ud83e\udd16 AI-FIRST Design\n\n**Traditional tools:** Optimize for human convenience (implicit context, smart defaults)\n**Breadcrumb:** Optimizes for AI reliability (explicit context, zero ambiguity)\n\n```bash\n# \u274c IMPLICIT (confusing for AI agents)\nbreadcrumb run python script.py # Which database? Which config?\nbreadcrumb query --gaps # Where are the traces?\n\n# \u2705 EXPLICIT (perfect for AI agents)\nbreadcrumb run -c myapp python script.py # Clear: using myapp config\nbreadcrumb query -c myapp --gaps # Clear: querying myapp database\n```\n\n**Result:** Zero context confusion across sessions. AI agents can resume debugging workflows perfectly.\n\n### \ud83d\udcca Smart Queries (No SQL Required)\n\nAI agents don't need to learn SQL. They just need structured data.\n\n```bash\n# Find untraced calls\nbreadcrumb query -c myapp --gaps\n\n# Show function I/O\nbreadcrumb query -c myapp --call send_webhook\n\n# Show execution timeline\nbreadcrumb query -c myapp --flow\n\n# Filter by module\nbreadcrumb query -c myapp --flow --module myapp\n\n# Search captured events for a literal string (function names, args, payloads, etc.)\nbreadcrumb query -c myapp --fuzzy breadcrumbs\n```\n\nAll output is structured JSON, ready for AI consumption.\n\nCall queries accept substrings, so `breadcrumb query -c myapp --call Pizza` resolves to\n`__main__.Pizza` (and its `__init__`) and `breadcrumb query -c myapp --call \"__main__.\"`\nreturns every function in `__main__`. Constructors capture their keyword arguments and\nreturn values automatically, making object creation auditable without extra logging.\n\nNeed a human-readable table? Switch formats:\n\n```bash\n# Table output with full values preserved for wide SQL results\nbreadcrumb --format table query -c myapp --disable-truncation \\\n \"SELECT function_name, data FROM trace_events ORDER BY timestamp DESC LIMIT 5\"\n\n# Increase captured payload size when recording new traces (default 2000 chars)\nbreadcrumb run -c myapp -t 60 --max-chars 5000 python main.py\n```\n\n### \ud83d\udeab Zero Code Changes\n\n```bash\n# \u2705 Just run with breadcrumb\nbreadcrumb run -c myapp --timeout 60 python main.py\n# NO code modifications needed!\n```\n\nYour codebase stays clean. Tracing is external.\n\n### \ud83d\udd12 Automatic Secret Redaction\n\nBreadcrumb automatically detects and redacts 50+ sensitive patterns:\n- Passwords, API keys, tokens\n- Credit cards, SSNs\n- JWTs, AWS keys, GitHub tokens\n\n```python\ndata = {\"api_key\": \"sk-1234567890\", \"password\": \"secret\"}\n# Stored as: {\"api_key\": \"[REDACTED]\", \"password\": \"[REDACTED]\"}\n```\n\n**Safe for production traces.**\n\n### \u26a1 Low Overhead\n\n- **PEP 669 backend** (Python 3.12+): < 2% overhead\n- **sys.settrace backend** (Python 3.8+): < 5% overhead\n- **Selective tracing**: Only trace what you need\n- **Async writes**: Non-blocking trace persistence\n\n---\n\n## Quick Start\n\n### Installation\n\n```bash\n# Using uv (recommended)\nuv pip install -e .\n\n# Or using pip\npip install -e .\n```\n\n### The Complete Workflow\n\n**1\ufe0f\u20e3 Initialize your project (one-time setup):**\n```bash\nbreadcrumb init myapp\n```\n\nCreates:\n- `~/.breadcrumb/myapp.yaml` (config with sensible defaults)\n- `~/.breadcrumb/myapp-traces.duckdb` (trace database)\n\n**2\ufe0f\u20e3 Run your code with tracing:**\n```bash\nbreadcrumb run -c myapp --timeout 60 python main.py\n```\n\nAutomatically traces execution. NO code changes needed.\n\n**3\ufe0f\u20e3 Find gaps in coverage:**\n```bash\nbreadcrumb query -c myapp --gaps\n```\n\nShows which functions were called but not traced.\n\n**4\ufe0f\u20e3 Expand tracing based on gaps:**\n```bash\nbreadcrumb config edit myapp --add-include 'requests.*'\nbreadcrumb config edit myapp --add-include 'sqlalchemy.*'\n```\n\n**5\ufe0f\u20e3 Re-run with expanded tracing:**\n```bash\nbreadcrumb run -c myapp --timeout 60 python main.py\n```\n\nNow traces additional modules!\n\n**6\ufe0f\u20e3 Query function details:**\n```bash\nbreadcrumb query -c myapp --call my_function\nbreadcrumb query -c myapp --call \"__main__.\" # Substring match, includes constructors\n```\n\nShows args, returns, duration, caller/callee relationships.\n\n**7\ufe0f\u20e3 View execution timeline:**\n```bash\nbreadcrumb query -c myapp --flow\n```\n\nShows chronological execution order with call stack depth.\n\n**8\ufe0f\u20e3 (Optional) Capture richer payloads:**\n```bash\nbreadcrumb run -c myapp --timeout 60 --max-chars 5000 python main.py\n```\n\nIncreases argument/return capture size without touching your source code.\n\n---\n\n## AI-FIRST Design Philosophy\n\n### Why `-c PROJECT` is REQUIRED\n\n**All commands require explicit project specification:**\n\n```bash\nbreadcrumb run -c myapp python script.py # REQUIRED\nbreadcrumb query -c myapp --gaps # REQUIRED\nbreadcrumb config edit myapp --add-include 'x' # REQUIRED\n```\n\n**This eliminates:**\n- \u274c \"Which database am I querying?\"\n- \u274c \"Which config is active?\"\n- \u274c \"Where did my traces go?\"\n- \u274c Context loss between AI agent sessions\n\n**Why it matters:**\n- **Humans:** \"Ugh, typing `-c myapp` every time is annoying!\"\n- **AI Agents:** \"Perfect! No ambiguity, no context confusion!\"\n\n**Design philosophy:** Explicit > Implicit for AI workflows.\n\nAI agents don't care about typing extra characters. They care about reliability across sessions.\n\n---\n\n## Command Reference\n\n### Core Commands\n\n```bash\n# Initialize project\nbreadcrumb init <project-name>\n\n# Run with tracing\nbreadcrumb run -c <project> --timeout <seconds> <command>\n\n# Smart queries\nbreadcrumb query -c <project> --gaps # Find untraced calls\nbreadcrumb query -c <project> --call <func> # Show function I/O\nbreadcrumb query -c <project> --flow # Show execution timeline\n\n# Inspect recorded traces\nbreadcrumb list -c <project>\nbreadcrumb get -c <project> <trace_id>\nbreadcrumb report -c <project>\nbreadcrumb top -c <project> 20\nbreadcrumb exceptions -c <project> --since 2h\nbreadcrumb clear -c <project> --force\n\n# Config management\nbreadcrumb config create <name>\nbreadcrumb config edit <name> --add-include <pattern>\nbreadcrumb config edit <name> --remove-include <pattern>\nbreadcrumb config show <name>\nbreadcrumb config list\n```\n\n### Query Examples\n\n```bash\n# Find what's not traced\nbreadcrumb query -c myapp --gaps\n\n# Show function with args/returns\nbreadcrumb query -c myapp --call process_payment\n\n# Show execution flow for module\nbreadcrumb query -c myapp --flow --module myapp\n\n# Substring call search (returns constructors too)\nbreadcrumb query -c myapp --call \"__main__.\" # All __main__ functions\nbreadcrumb query -c myapp --call Pizza # Matches __main__.Pizza/__init__\n\n# Raw SQL query (still supported)\nbreadcrumb query -c myapp --sql \"SELECT * FROM traces WHERE status='failed'\"\n```\n\n### Config Examples\n\n```bash\n# Start with minimal tracing\nbreadcrumb init myapp\n# Creates config with include: ['__main__']\n\n# Expand based on gaps\nbreadcrumb config edit myapp --add-include 'requests.*'\nbreadcrumb config edit myapp --add-include 'sqlalchemy.*'\nbreadcrumb config edit myapp --add-include 'myapp.services.*'\n\n# Remove noisy modules\nbreadcrumb config edit myapp --remove-include 'logging.*'\n\n# View current config\nbreadcrumb config show myapp\n```\n\n---\n\n## Use Cases for AI Coding Agents\n\n### 1. Understanding Legacy Code\n\n**Human approach:**\n- Read docs (if they exist)\n- Step through with debugger\n- Ask teammates\n\n**AI agent approach:**\n```bash\n# Run the code\nbreadcrumb run -c legacy --timeout 120 python legacy_system.py\n\n# See what actually executed\nbreadcrumb query -c legacy --flow\n\n# Find entry points\nbreadcrumb query -c legacy --gaps\n```\n\n**Result:** AI agent sees actual execution flow, not just static code.\n\n### 2. Debugging API Integration Issues\n\n**Human approach:**\n- Add print statements\n- Check API logs\n- Use network inspector\n\n**AI agent approach:**\n```bash\n# Trace the integration\nbreadcrumb config edit myapp --add-include 'requests.*'\nbreadcrumb run -c myapp --timeout 60 python test_api.py\n\n# See exact API calls\nbreadcrumb query -c myapp --call 'requests.post'\n```\n\n**Result:** AI agent sees exact request args, response values, and timing.\n\n### 3. Performance Investigation\n\n**Human approach:**\n- Use profiler\n- Add timing code\n- Analyze bottlenecks\n\n**AI agent approach:**\n```bash\n# Run with tracing\nbreadcrumb run -c myapp --timeout 300 python load_test.py\n\n# Find slow functions\nbreadcrumb query -c myapp --sql \"SELECT function_name, AVG(duration_ms) FROM trace_events GROUP BY function_name ORDER BY AVG(duration_ms) DESC LIMIT 10\"\n```\n\n**Result:** AI agent identifies performance bottlenecks from real execution data.\n\n### 4. Test Failure Analysis\n\n**Human approach:**\n- Re-run test\n- Add debug output\n- Check assertions\n\n**AI agent approach:**\n```bash\n# Run failing test with tracing\nbreadcrumb run -c tests --timeout 60 pytest tests/test_payment.py::test_refund\n\n# See what actually happened\nbreadcrumb query -c tests --call process_refund\n\n# Check execution flow\nbreadcrumb query -c tests --flow --module myapp.payments\n```\n\n**Result:** AI agent sees exact execution path that led to failure.\n\n---\n\n## MCP Integration (Claude Desktop)\n\nBreadcrumb includes an MCP server for Claude Desktop integration.\n\n**Setup:**\n\nAdd to `claude_desktop_config.json`:\n```json\n{\n \"mcpServers\": {\n \"breadcrumb\": {\n \"command\": \"breadcrumb\",\n \"args\": [\"serve-mcp\"],\n \"env\": {}\n }\n }\n}\n```\n\n**Available Tools:**\n- `breadcrumb__query_traces` - Execute SQL queries\n- `breadcrumb__get_trace` - Get trace details by ID\n- `breadcrumb__find_exceptions` - Find exceptions in traces\n- `breadcrumb__analyze_performance` - Analyze function performance\n\n**Usage:**\n```\nTell Claude: \"Use breadcrumb to find the last exception in my app\"\nClaude will use: breadcrumb__find_exceptions\n```\n\n---\n\n## Advanced Configuration\n\n### Python API (Optional)\n\nIf you need programmatic control, you can still use the Python API:\n\n```python\nimport breadcrumb\n\n# Basic configuration\nbreadcrumb.init(\n enabled=True,\n sample_rate=1.0,\n db_path=\"~/.breadcrumb/myapp-traces.duckdb\",\n include=[\"myapp.*\", \"requests.*\"]\n)\n\n# Your code here\ndef my_function():\n pass\n```\n\n**But 99% of use cases should use `breadcrumb run` instead.**\n\n### Environment Variables\n\n```bash\n# Override config settings\nexport BREADCRUMB_ENABLED=true\nexport BREADCRUMB_DB_PATH=\"/custom/path/traces.duckdb\"\nexport BREADCRUMB_SAMPLE_RATE=0.5\n```\n\n---\n\n## Database Schema\n\nBreadcrumb stores traces in DuckDB with these tables:\n\n**traces** - One row per execution:\n```sql\nCREATE TABLE traces (\n id VARCHAR PRIMARY KEY,\n started_at TIMESTAMP,\n ended_at TIMESTAMP,\n status VARCHAR, -- 'running', 'completed', 'failed'\n duration_ms DOUBLE\n);\n```\n\n**trace_events** - Function calls and returns:\n```sql\nCREATE TABLE trace_events (\n id VARCHAR PRIMARY KEY,\n trace_id VARCHAR,\n timestamp TIMESTAMP,\n event_type VARCHAR, -- 'call', 'return', 'exception', 'call_site'\n function_name VARCHAR,\n module_name VARCHAR,\n data JSON -- Contains: args, kwargs, return_value, caller info\n);\n```\n\n**Direct SQL access:**\n```python\nimport duckdb\nconn = duckdb.connect('~/.breadcrumb/myapp-traces.duckdb')\nresult = conn.execute(\"SELECT * FROM traces\").fetchall()\n```\n\n---\n\n## How It Works\n\n### Architecture\n\n1. **PEP 669 Backend (Python 3.12+)**\n - Uses sys.monitoring API (low overhead)\n - Captures function calls/returns automatically\n - Detects untraced calls for gap detection\n\n2. **Trace Storage (DuckDB)**\n - Fast columnar database\n - JSON support for flexible data\n - SQL queryable for complex analysis\n\n3. **Smart Query Layer**\n - Abstracts SQL complexity\n - Returns structured JSON\n - Optimized for AI agent consumption\n\n4. **CLI Interface**\n - Typer-based commands\n - Explicit project specification\n - AI-FIRST design principles\n\n### Include-Only Workflow\n\n**Default behavior:** Trace only `__main__` module (minimal overhead)\n\n**Iterative expansion:**\n```bash\nbreadcrumb run -c myapp python script.py # Trace __main__ only\nbreadcrumb query -c myapp --gaps # Find what's not traced\nbreadcrumb config edit myapp --add-include 'requests.*' # Expand\nbreadcrumb run -c myapp python script.py # Trace more\n```\n\n**Philosophy:** Start minimal, expand based on what you discover.\n\nThis is **much better** than tracing everything and filtering later.\n\n---\n\n## Performance\n\nBreadcrumb is designed for production use:\n\n**Overhead benchmarks (1M function calls):**\n- Baseline: 0.85s\n- With Breadcrumb (PEP 669): 0.87s (2.4% overhead)\n- With Breadcrumb (settrace): 0.89s (4.7% overhead)\n\n**Optimization strategies:**\n- Selective tracing (include patterns)\n- Async database writes\n- Value truncation (prevent bloat)\n- Smart sampling (optional)\n\n---\n\n## Security\n\n**Automatic secret redaction** prevents sensitive data from reaching traces:\n\n**Detected patterns:**\n- Password fields (`password`, `passwd`, `pwd`, `secret`)\n- API keys (`api_key`, `apikey`, `token`, `bearer`)\n- Credit cards (16-digit patterns)\n- SSNs (XXX-XX-XXXX format)\n- JWTs (eyJ... tokens)\n- AWS keys (AKIA... patterns)\n- GitHub tokens (ghp_... patterns)\n\n**Custom patterns:**\n```python\nfrom breadcrumb.capture.secret_redactor import configure_redactor\nconfigure_redactor(custom_patterns=['my_secret_*', 'internal_token'])\n```\n\n---\n\n## Requirements\n\n- **Python 3.12+** (recommended for PEP 669 backend)\n- **Python 3.10+** (falls back to sys.settrace backend)\n- **DuckDB 1.4.1+**\n- **FastMCP 2.12.4+** (for MCP server)\n- **Typer 0.19.2+** (for CLI)\n\n---\n\n## Status\n\n**Current version:** 0.2.0 (Beta)\n\n**Production-ready features:**\n- \u2705 PEP 669 tracing backend\n- \u2705 Zero-code-change execution (`breadcrumb run`)\n- \u2705 Gap detection (`--gaps` command)\n- \u2705 Smart queries (no SQL needed)\n- \u2705 AI-FIRST design (explicit `-c` everywhere)\n- \u2705 Automatic secret redaction\n- \u2705 DuckDB storage\n- \u2705 MCP server integration\n\n**Coming soon:**\n- \ud83d\udea7 `--call` command (show function I/O details)\n- \ud83d\udea7 `--flow` command (execution timeline)\n- \ud83d\udce6 PyPI package\n- \ud83d\udcca Performance visualizations\n- \u2601\ufe0f Cloud storage backends\n\n---\n\n## Contributing\n\nWe welcome contributions! This project is built for AI coding agents.\n\n**Development setup:**\n```bash\ngit clone https://github.com/AndreRatzenberger/breadcrumb-tracer.git\ncd breadcrumb-tracer\nuv pip install -e .\npytest tests/\n```\n\n**Key principles:**\n- AI-FIRST design (explicit over implicit)\n- Zero code changes required\n- Performance matters (< 5% overhead)\n- Test-driven development\n\n---\n\n## License\n\nMIT License - see LICENSE file for details.\n\n---\n\n## Acknowledgments\n\nBuilt with:\n- [PEP 669 (sys.monitoring)](https://peps.python.org/pep-0669/) - Low-overhead monitoring API\n- [DuckDB](https://duckdb.org/) - Embedded analytical database\n- [FastMCP](https://github.com/jlowin/fastmcp) - MCP server framework\n- [Typer](https://typer.tiangolo.com/) - CLI framework\n\nSpecial thanks to the Model Context Protocol team at Anthropic for enabling AI-native tooling.\n\n---\n\n## The Bottom Line\n\n**Humans debug with debuggers.**\n**AI agents debug with execution traces.**\n\nBreadcrumb gives AI coding agents the X-ray vision they need to understand what your code actually does - not just what it's supposed to do.\n\nNo code changes. No manual logging. No guessing.\n\nJust structured execution data, queryable in real-time.\n\n**That's Breadcrumb.** \ud83c\udf5e\n",
"bugtrack_url": null,
"license": "MIT",
"summary": "An automatic, non-intrusive execution tracer for Python for iterative IDE-less debugging and code-flow analysis",
"version": "0.2.13",
"project_urls": {
"Documentation": "https://github.com/yourusername/breadcrumb#readme",
"Homepage": "https://github.com/yourusername/breadcrumb",
"Issues": "https://github.com/yourusername/breadcrumb/issues",
"Repository": "https://github.com/yourusername/breadcrumb"
},
"split_keywords": [
"ai",
" claude",
" debugging",
" execution-tracer",
" instrumentation",
" llm",
" mcp",
" observability",
" profiling",
" tracing"
],
"urls": [
{
"comment_text": null,
"digests": {
"blake2b_256": "412d6a8b77c3a4baa366b8631f963b96e8a33152787faa3ab8433cadd3edf647",
"md5": "1fdba4a6833e998b435b93c0641e4c40",
"sha256": "81ad5dda8f739899608fcdc972f2ed79eb7706bdd5bfa2b94785fde7e664d8af"
},
"downloads": -1,
"filename": "breadcrumb-0.2.13-py3-none-any.whl",
"has_sig": false,
"md5_digest": "1fdba4a6833e998b435b93c0641e4c40",
"packagetype": "bdist_wheel",
"python_version": "py3",
"requires_python": ">=3.10",
"size": 103765,
"upload_time": "2025-10-12T01:43:34",
"upload_time_iso_8601": "2025-10-12T01:43:34.934974Z",
"url": "https://files.pythonhosted.org/packages/41/2d/6a8b77c3a4baa366b8631f963b96e8a33152787faa3ab8433cadd3edf647/breadcrumb-0.2.13-py3-none-any.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": null,
"digests": {
"blake2b_256": "3441a8ef09d200f3f41eaaaf0f89ce37f97ee7bd69829182a6ad2088db6b6959",
"md5": "8c4f2f711a1392baa95104b22378747a",
"sha256": "e68f97c0eae329856663b4adf6e16d96a48f128aa5efede6023a93d0bce4d7b3"
},
"downloads": -1,
"filename": "breadcrumb-0.2.13.tar.gz",
"has_sig": false,
"md5_digest": "8c4f2f711a1392baa95104b22378747a",
"packagetype": "sdist",
"python_version": "source",
"requires_python": ">=3.10",
"size": 645092,
"upload_time": "2025-10-12T01:43:36",
"upload_time_iso_8601": "2025-10-12T01:43:36.708441Z",
"url": "https://files.pythonhosted.org/packages/34/41/a8ef09d200f3f41eaaaf0f89ce37f97ee7bd69829182a6ad2088db6b6959/breadcrumb-0.2.13.tar.gz",
"yanked": false,
"yanked_reason": null
}
],
"upload_time": "2025-10-12 01:43:36",
"github": true,
"gitlab": false,
"bitbucket": false,
"codeberg": false,
"github_user": "yourusername",
"github_project": "breadcrumb#readme",
"github_not_found": true,
"lcname": "breadcrumb"
}
JSON
