TLDR Code Analysis

Token-efficient codebase analysis using llm-tldr. 95% fewer tokens than reading raw files.

Quick Reference

Task	Command
"How does X work?"	`semantic` → `context`
"Who calls X?"	`impact`
"What would break?"	`impact` + `change_impact`
"Why is X null here?"	`slice` (backward)
"What does X affect?"	`slice` (forward)
"Project structure?"	`arch` + `structure`
"Find auth code"	`semantic "authentication"`
"Data flow in function"	`dfg`
"Control flow"	`cfg`
"Find dead code"	`dead`
"Type errors?"	`diagnostics`

Commands

Semantic Search (Natural Language)

Find code by meaning, not exact text:

code

mcp__tldr__semantic { "project": ".", "query": "user authentication flow" }
mcp__tldr__semantic { "project": ".", "query": "error handling" }

Function Context (95% Token Savings)

Get LLM-ready summary instead of reading entire file:

code

mcp__tldr__context { "project": ".", "entry": "handleLogin", "depth": 2 }

Impact Analysis (Before Refactoring)

Find all callers - critical before changing any function:

code

mcp__tldr__impact { "project": ".", "function": "useAuth" }

Architecture Overview

Understand project layers and dependencies:

code

mcp__tldr__arch { "project": "." }

Program Slice (Debugging)

What affects a specific line (backward) or what it affects (forward):

code

mcp__tldr__slice {
  "file": "src/auth.ts",
  "function": "login",
  "line": 42,
  "direction": "backward",
  "variable": "user"
}

Call Graph

Cross-file function call relationships:

code

mcp__tldr__calls { "project": ".", "language": "typescript" }

Data Flow Graph

Variable references and def-use chains:

code

mcp__tldr__dfg { "file": "src/auth.ts", "function": "validateToken" }

Control Flow Graph

Basic blocks and branching:

code

mcp__tldr__cfg { "file": "src/auth.ts", "function": "handleRequest" }

Change Impact (Affected Tests)

Find tests affected by changed files:

code

mcp__tldr__change_impact { "project": "." }

Dead Code Detection

Find unreachable code:

code

mcp__tldr__dead { "project": ".", "entry_points": ["main", "test_"] }

Import Analysis

Parse imports or find importers:

code

mcp__tldr__imports { "file": "src/utils.ts" }
mcp__tldr__importers { "project": ".", "module": "auth" }

Diagnostics (Type/Lint)

Type checking and linting:

code

mcp__tldr__diagnostics { "path": "src/", "language": "typescript" }

Structure Overview

Functions, classes, methods per file:

code

mcp__tldr__structure { "project": ".", "language": "typescript", "max_results": 50 }

Workflow Patterns

Understanding Code

code

1. tldr arch .                    # Get project overview
2. tldr semantic "feature name"   # Find relevant code
3. tldr context functionName      # Get LLM-ready summary
4. Read (only if more detail needed)

Before Refactoring

code

1. tldr impact functionName       # Who calls this?
2. tldr change_impact             # What tests affected?
3. tldr context functionName      # Understand the function
4. Make changes
5. tldr diagnostics src/          # Check for errors

Debugging

code

1. tldr slice file func line      # What affects this line?
2. tldr dfg file func             # Data flow analysis
3. tldr context func              # Understand function

Prerequisites

bash

pipx install llm-tldr
tldr daemon start     # Background service (300x faster)
tldr warm .           # Build indexes including embeddings

CRITICAL RULES

•ALWAYS use tldr context BEFORE reading large files
•ALWAYS use tldr impact BEFORE refactoring
•ALWAYS use tldr semantic for "how does X work" questions
•Use grep ONLY for exact string matching

Output

Return findings with:

•Relevant code: Key functions/files found
•Call chain: How things connect
•Recommendations: Next steps based on analysis
•Store as learning if discovering non-obvious patterns