extracting-code-structure

iota9star's avatarfrom iota9star

Extracts file structure (functions, classes, exports) efficiently without reading entire files, using ast-grep, Dart/Flutter analyzer, ctags, or other language-specific tools to get outlines and signatures. Use this skill when listing all methods, functions, or classes in a file, exploring unfamiliar code, getting API overviews, or deciding what to read selectively

⭐5stars🔀0forks📁View on GitHub🕐Updated Dec 24, 2025
[Developer Tools]

When & Why to Use This Skill

The extracting-code-structure skill is a high-efficiency utility designed to map and analyze source code architecture without the overhead of reading entire files. By leveraging advanced tools like ast-grep, ctags, and language-specific analyzers (such as Dart/Flutter and TypeScript), it provides instant access to function signatures, class hierarchies, and module exports. This skill is essential for optimizing LLM context usage, enabling agents and developers to navigate large-scale repositories, perform rapid API discovery, and understand complex codebases while saving up to 90% of token consumption.

Use Cases

  • Rapid Codebase Onboarding: Quickly map out the architecture of an unfamiliar repository by listing all classes and methods to understand the project structure in seconds.
  • Context-Efficient Debugging: Extract specific function signatures and method receivers to understand dependencies without hitting context window limits on large files.
  • API and Export Discovery: Generate a comprehensive overview of public APIs and exported members in a module to identify available functionality for integration.
  • Pre-Refactoring Analysis: Use structural outlines to identify components for modification and ensure consistent implementation across different files before writing code.
  • Selective Code Reading: Get a high-level index of a file (>500 lines) to decide exactly which sections require a deep dive, improving focus and efficiency.
nameextracting-code-structure
descriptionExtracts file structure (functions, classes, exports) efficiently without reading entire files, using ast-grep, Dart/Flutter analyzer, ctags, or other language-specific tools to get outlines and signatures. Use this skill when listing all methods, functions, or classes in a file, exploring unfamiliar code, getting API overviews, or deciding what to read selectively

Code Structure Exploration Tools

Always invoke extracting-code-structure skill to extract file structure - do not execute bash commands directly.

Recognizing Structure Questions

These keywords mean use structure tools, NOT grep/search:

  • "all the methods/functions/classes in..."
  • "list of function signatures"
  • "what functions/exports/API..."
  • "package API" or "module exports"
  • "method signatures with receivers" (Dart/Flutter, TypeScript)
  • "what's available in..."

These keywords mean use search (Grep tool or extracting-code-structure skill):

  • "where is X defined"
  • "find calls to X"
  • "search for pattern Y"

Before You Choose a Tool

Ask yourself:

  1. Am I listing/exploring what exists? → Structure tools
  2. Am I finding WHERE something is? → Search tools (Grep or ast-grep)
  3. Am I understanding HOW something works? → Read

When to Get File Outline vs Read

Get outline/index when:

  • File is large (>500 lines)
  • Need to see what's available (functions, classes, exports)
  • Exploring unfamiliar code
  • Want to decide what to read in detail
  • Saves 90%+ context vs reading entire file

Just use Read when:

  • File is small (<500 lines)
  • Already know what you're looking for
  • Need to understand implementation details
  • extracting-code-structure pattern already targets what you need

Anti-Patterns

DON'T use grep/rg/Grep tool for:

  • Extracting function/method lists
  • Getting API overviews
  • Finding all exports/public members
  • Getting signatures/interfaces

These are STRUCTURE queries, not SEARCH queries.

Default Strategy

Invoke extracting-code-structure skill for extracting file structure (functions, classes, exports) efficiently without reading entire files.

Use ast-grep patterns, Dart/Flutter analyzer, ctags, or language-specific tools to get outlines and signatures. Dart/Flutter and JavaScript/TypeScript support have highest priority.

Exploration Strategy

Tiered approach (try in order):

  1. ast-grep with known patterns - Fast, targeted (highest priority)

    • Extract exports, functions, classes with specific patterns
    • See code structure guide for patterns, including comprehensive Dart/Flutter support

  2. Toolchain-specific approaches - When available

    • Dart/Flutter analyzer - Comprehensive structure extraction for .dart files
    • ctags/universal-ctags: Symbol index across languages
    • See code structure guide for examples

  3. Read file - Last resort for exploration

    • Sometimes necessary to understand structure

Key Principle

Use structure tools to decide what to read, then read selectively.

Don't read 1000-line files blind. Get an outline first, then read the 50 lines you actually need.

Skill Combinations

For Discovery and Exploration

  • extracting-code-structure → fd: Find files of a specific type, then get structure
  • extracting-code-structure → ripgrep: Understand structure, then search for specific patterns
  • extracting-code-structure → analyzing-code-structure: Get outline, then perform structural refactoring
  • extracting-code-structure → jq/yq: Understand API structures before extracting data

In Refactoring Workflows

  • extracting-code-structure → fzf → analyzing-code-structure: Interactive selection of components to refactor
  • extracting-code-structure → ripgrep → sd: Find patterns and perform replacements

For Documentation and Analysis

  • extracting-code-structure → tokei: Get statistics for specific code components
  • extracting-code-structure → bat: View structure with syntax highlighting

Multi-Skill Workflows

  • extracting-code-structure → ripgrep → analyzing-code-structure → bat: Complete code analysis and refactoring pipeline
  • extracting-code-structure → fd → jq/yq: Find and analyze configuration structures
  • extracting-code-structure → fzf → sd: Interactive selection and modification of code elements

Integration Examples

# Get structure and find all methods
ast-grep -r 'function $FUNC($$$ARGS) {$$$BODY}' src/ | fzf | cut -d: -f1 | xargs -I {} bat {}

# Understand API and extract usage
yq '.endpoints' api.yml | fzf | ripgrep -A 10 -B 5

Detailed Patterns

For language-specific extraction patterns, ast-grep examples, ctags usage, and integration strategies, load code structure guide when needing:

  • Dart/Flutter specific patterns and analyzer usage
  • Language-specific extraction strategies
  • ctags configuration and usage
  • Comprehensive workflow examples
  • Tool selection guidance for different languages