code-analyze 0.1.1

Analyze code structure and relationships using tree-sitter
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98

---
name: code-analyze
description: Analyze code structure and relationships using tree-sitter. Use when you need to understand a codebase, find function definitions, track symbol usage across files, or get a structural overview of a directory.
---

# Code Analyzer

Static code analysis CLI using tree-sitter parsing.

## Usage

```bash
scripts/analyze [-f SYMBOL] [-d DEPTH] [-m DEPTH] <PATH>
```

## Modes

The tool auto-selects its mode based on arguments:

- **Directory** → file tree with LOC, function, and class counts
- **File** → functions, classes, imports, call relationships
- **Focused** (`-f`) → track a symbol across files with call chains

## Output Format

### File header
```
FILE: path/to/file.rs [151L, 1F, 1C]
```
`L` = lines, `F` = functions, `C` = classes/structs

### Sections

| Prefix | Meaning | Example |
|--------|---------|---------|
| `C:` | Classes/structs with line numbers | `Args:34` |
| `F:` | Functions with line numbers | `main:60`, `parse:42•4` (•N = cyclomatic complexity) |
| `I:` | Imports, `(N)` = grouped count | `use std(2)` |
| `R:` | References | `methods[name(Type)]`, `types[Name]`, `fields[Type]` |

### Directory output
```
SUMMARY:
Shown: 19 files, 2678L, 69F, 30C (max_depth=3)
Languages: rust (100%)

PATH [LOC, FUNCTIONS, CLASSES]
  mod.rs [306L, 9F, 3C]
  parser.rs [450L, 14F, 5C]
```

### Focused output (`-f SYMBOL`)
```
FOCUSED ANALYSIS: analyze

DEFINITIONS:
F1:221 - analyze

OUTGOING CALL CHAINS (depth=2):
F1:228 (analyze -> Path::new)
F1:246 (analyze -> analyze_focused) -> F1:174 (analyze_focused -> CallGraph::build_from_results)

FILES:
  F1: src/analyze/mod.rs
  F2: src/analyze/traversal.rs
```

Format: `F<file>:<line> (caller -> callee)`. File index maps to `FILES:` section.

## Options

| Flag | Default | Description |
|------|---------|-------------|
| `-f SYMBOL` | — | Track symbol across files |
| `-d DEPTH` | 2 | Call graph depth (0 = definition only) |
| `-m DEPTH` | 3 | Directory recursion limit (0 = unlimited) |
| `--ast-recursion-limit N` | unlimited | Prevent stack overflow in deeply nested code |

## Examples

```bash
scripts/analyze src/main.rs             # single file analysis
scripts/analyze src/                    # directory overview
scripts/analyze -f handle_request .     # track symbol across codebase
scripts/analyze -m 1 .                  # shallow overview
scripts/analyze -f process -d 4 src/    # deep call chain tracking
```

## Supported Languages

- Python
- Rust
- JavaScript / TypeScript
- Go
- Java
- Kotlin
- Swift
- Ruby