tldr-deep
π―Skillfrom parcadei/continuous-claude-v3
Generates a comprehensive 5-layer code analysis for a specific function, revealing its structure, call graph, control flow, data flow, and dependencies.
Installation
npx skills add https://github.com/parcadei/continuous-claude-v3 --skill tldr-deepSkill Details
Full 5-layer analysis of a specific function. Use when debugging or deeply understanding code.
Overview
# TLDR Deep Analysis
Full 5-layer analysis of a specific function. Use when debugging or deeply understanding code.
Trigger
/tldr-deep- "analyze function X in detail"
- "I need to deeply understand how Y works"
- Debugging complex functions
Layers
| Layer | Purpose | Command |
|-------|---------|---------|
| L1: AST | Structure | tldr extract |
| L2: Call Graph | Navigation | tldr context |
| L3: CFG | Complexity | tldr cfg |
| L4: DFG | Data flow | tldr dfg |
| L5: Slice | Dependencies | tldr slice |
Execution
Given a function name, run all layers:
```bash
# First find the file
tldr search "def
# Then run each layer
tldr extract
tldr context
tldr cfg
tldr dfg
tldr slice
```
Output Format
```
Deep Analysis: {function_name}
L1: Structure (AST)
File: {file_path}
Signature: {signature}
Docstring: {docstring}
L2: Call Graph
Calls: {list of functions this calls}
Called by: {list of functions that call this}
L3: Control Flow (CFG)
Blocks: {N}
Cyclomatic Complexity: {M}
[Hot if M > 10]
Branches:
- if: line X
- for: line Y
- ...
L4: Data Flow (DFG)
Variables defined:
- {var1} @ line X
- {var2} @ line Y
Variables used:
- {var1} @ lines [A, B, C]
- {var2} @ lines [D, E]
L5: Program Slice (affecting line {target})
Lines in slice: {N}
Key dependencies:
- line X β line Y (data)
- line A β line B (control)
---
Total: ~{tokens} tokens (95% savings vs raw file)
```
When to Use
- Debugging - Need to understand all paths through a function
- Refactoring - Need to know what depends on what
- Code review - Analyzing complex functions
- Performance - Finding hot spots (high cyclomatic complexity)
Programmatic API
```python
from tldr.api import (
extract_file,
get_relevant_context,
get_cfg_context,
get_dfg_context,
get_slice
)
# All layers for one function
file_info = extract_file("src/processor.py")
context = get_relevant_context("src/", "process_data", depth=2)
cfg = get_cfg_context("src/processor.py", "process_data")
dfg = get_dfg_context("src/processor.py", "process_data")
slice_lines = get_slice("src/processor.py", "process_data", target_line=42)
```
More from this repository10
Enables seamless integration between Agentica agents and Claude Code CLI by managing proxy configurations, tool permissions, and response formatting.
Manages git commits by removing Claude attribution, generating reasoning documentation, and ensuring clean commit workflows.
Systematically diagnose and resolve hook registration, execution, and output issues in Claude Code projects by checking cache, settings, files, and manual testing.
Systematically researches, analyzes, plans, implements, and reviews migrations across frameworks, languages, and infrastructure with minimal risk.
Enables background agent execution with system-triggered progress notifications, avoiding manual polling and context flooding.
Provides comprehensive reference and infrastructure for building sophisticated multi-agent coordination patterns and workflows with precise API specifications and tracking mechanisms.
Generates a comprehensive summary of the current system's configuration, components, and key metrics across skills, agents, hooks, and other core systems.
Provides comprehensive CLI commands and flags for interacting with Claude Code, enabling headless mode, automation, and session management.
Traces and correlates Claude Code session events across parent and sub-agent interactions using comprehensive Braintrust instrumentation.
Rapidly edits files using AI-powered Morph Apply API with high accuracy and speed, without requiring full file context.