# View repository map in interactive mode
>>> /map

# Or use Python API
from praisonai.cli.features import RepoMapHandler

handler = RepoMapHandler()
handler.initialize(root="/path/to/project")
print(handler.get_map())

src/app.py:
  │class Application:
  │    def __init__(self):
  │    def run(self):
  │    def configure(self, config):
  ⋮...

src/models/user.py:
  │class User:
  │    def __init__(self, name, email):
  │    def validate(self):
  ⋮...

src/utils/helpers.py:
  │def format_date(date):
  │def parse_json(data):
  ⋮...

from praisonai.cli.features import RepoMapHandler

# Initialize
handler = RepoMapHandler()
repo_map = handler.initialize(root="/path/to/project")

# Get the map
map_str = handler.get_map()
print(map_str)

from praisonai.cli.features.repo_map import RepoMap, RepoMapConfig

# Custom configuration
config = RepoMapConfig(
    max_tokens=2048,           # Max tokens for the map
    max_files=100,             # Max files to include
    max_symbols_per_file=30,   # Max symbols per file
    include_imports=True,      # Include import statements
    file_extensions={".py", ".js", ".ts"},  # File types to scan
    exclude_patterns={"__pycache__", "node_modules", ".git"}
)

# Create map with config
repo_map = RepoMap(root="/path/to/project", config=config)
repo_map.scan()

map_str = repo_map.get_map()

# Get map with focus on specific files
map_str = handler.get_map(focus_files=[
    "src/main.py",
    "src/api/routes.py"
])

# Get context around a symbol
context = handler.get_context("Application")

# Returns:
# src/app.py:15
# class Application:
#     """Main application class."""
#     
#     def __init__(self):
#         self.config = {}
#     ...

# Extracts:
class MyClass:           # class
    def method(self):    # method
        pass

def my_function():       # function
    pass

// Extracts:
class Component {}       // class
function helper() {}     // function
const util = () => {}    // arrow function
export class Service {}  // exported class

// Extracts:
type MyStruct struct {}  // struct (as class)
func MyFunction() {}     // function
func (m *MyStruct) Method() {}  // method

// Extracts:
pub struct MyStruct {}   // struct (as class)
fn my_function() {}      // function
pub async fn async_fn() {}  // async function

// Extracts:
public class MyClass {}  // class
public void method() {}  // method
interface MyInterface {} // interface

pip install tree-sitter-languages

>>> /map
╭─────────────────────────────────────────────────╮
│              📁 Repository Map                  │
├─────────────────────────────────────────────────┤
│ src/app.py:                                     │
│   │class Application:                           │
│   │    def __init__(self):                      │
│   │    def run(self):                           │
│   ⋮...                                          │
│                                                 │
│ src/models/user.py:                             │
│   │class User:                                  │
│   │    def __init__(self, name):                │
│   ⋮...                                          │
╰─────────────────────────────────────────────────╯

# Map a specific directory instead of the workspace root
>>> /map src/api

from praisonai.cli.features.repo_map import SymbolExtractor, Symbol

extractor = SymbolExtractor(use_tree_sitter=True)

# Extract from file content
content = '''
class MyClass:
    def method(self):
        pass

def helper():
    pass
'''

symbols = extractor.extract_symbols("test.py", content)

for symbol in symbols:
    print(f"{symbol.kind}: {symbol.name} at line {symbol.line_number}")
# Output:
# class: MyClass at line 1
# method: method at line 2
# function: helper at line 5

from praisonai.cli.features.repo_map import SymbolRanker

ranker = SymbolRanker()

# Analyze references across files
ranker.analyze_references(file_maps, all_content)

# Get top symbols
top_symbols = ranker.get_top_symbols(file_maps, max_symbols=20)

for symbol in top_symbols:
    print(f"{symbol.name}: {symbol.references} references")

# After file changes, refresh the map
handler.refresh()

# Get updated map
new_map = handler.get_map()

from praisonai.cli.features import RepoMapHandler

# Initialize
repo_handler = RepoMapHandler()
repo_handler.initialize(root=".")

# Get map for AI context
repo_map = repo_handler.get_map(max_tokens=1024)

# Include in prompt
prompt = f"""
Repository structure:
{repo_map}

User request: {user_input}
"""

config = RepoMapConfig(
    max_tokens=1024,  # Limit total tokens
    max_files=50,     # Limit files scanned
    max_symbols_per_file=20  # Limit symbols per file
)

# First call - scans repository
map1 = handler.get_map()

# Second call - uses cache
map2 = handler.get_map()

# Force refresh
handler.refresh()
map3 = handler.get_map()