smart-explore

Discover and outline functions, classes, and modules across codebases using tree-sitter parsing.

Updated Jun 19, 2026
One-click install
npx skills add https://github.com/Intelligent-Resourcing-Team-Environment/claude-memory --skill smart-explore-intelligent-resourcing-team-environment
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: smart-explore
Source: https://github.com/Intelligent-Resourcing-Team-Environment/claude-memory/tree/main/plugin/skills/smart-explore
Command: npx skills add https://github.com/Intelligent-Resourcing-Team-Environment/claude-memory --skill smart-explore-intelligent-resourcing-team-environment

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Quickly understanding large codebases by prioritizing a map of structure over full file reads, enabling fast orientation and targeted deep dives via AST-based exploration.

Core Features & Use Cases

  • Index-first exploration: Build a structural overview before fetching implementations.
  • Symbol discovery with smart_search: Locate functions, classes, and modules across a repository.
  • On-demand deep dives with smart_outline and smart_unfold: Retrieve full symbol structure or implementation as needed.
  • Use Case: Navigate a multi-language project to identify where a core function is implemented and view its signature without loading every file.

Quick Start

Start by using smart_search to map symbols across the codebase, then outline a key file to see its structure, and finally unfold a symbol to view its implementation.

Frequently Asked Questions about smart-explore

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I explore code structure in a large multi-language codebase?

To explore code structure in a large multi-language codebase, use AST-based parsing to index symbols first. This approach builds a structural overview, allowing you to locate functions and classes without loading full file implementations.

What is the best way to find where a function is implemented across a repository?

The best way to find where a function is implemented across a repository is using symbol discovery tools. By searching the AST index, you can locate specific functions, classes, or modules and view their signatures before fetching the full implementation.

How does AST parsing help with code navigation?

AST parsing helps with code navigation by converting source files into a structural map of symbols. This allows you to quickly outline files and unfold specific functions on demand, prioritizing high-level understanding over reading entire files.

Can I view a function signature without loading the entire source file?

Yes, you can view a function signature without loading the entire source file by using on-demand deep dive tools. These tools unfold specific symbols from the AST index, retrieving only the targeted implementation rather than the full file content.

Does tree-sitter based code exploration work for large projects?

Tree-sitter based code exploration works effectively for large projects. It prioritizes building a structural map of the codebase first, enabling fast orientation and targeted deep dives into specific modules without the overhead of loading every file.

What are the limitations of using AST-based code exploration?

The limitation of AST-based code exploration is that it prioritizes structural overview over full file reads. While excellent for fast navigation and locating symbols, you must explicitly unfold specific symbols to view their complete implementation details.