GrepAI Supported Languages

This skill covers the programming languages supported by GrepAI for indexing and call graph analysis.

When to Use This Skill

Checking if your language is supported
Configuring language-specific settings
Understanding trace capabilities per language
Troubleshooting language-related issues

Supported Languages Overview

GrepAI supports indexing for all text-based files, but has enhanced support for specific programming languages.

Full Support (Index + Trace)

Language	Extensions	Index	Trace
Go	`.go`	✅	✅
JavaScript	`.js`, `.jsx`	✅	✅
TypeScript	`.ts`, `.tsx`	✅	✅
Python	`.py`	✅	✅
PHP	`.php`	✅	✅
C	`.c`, `.h`	✅	✅
C++	`.cpp`, `.hpp`, `.cc`, `.cxx`, `.hh`	✅	✅
Rust	`.rs`	✅	✅
Zig	`.zig`	✅	✅
C#	`.cs`	✅	✅
Java	`.java`	✅	✅
Pascal/Delphi	`.pas`, `.dpr`	✅	✅

Index Only (No Trace)

Language	Extensions	Index	Trace
Ruby	`.rb`	✅	❌
Swift	`.swift`	✅	❌
Kotlin	`.kt`, `.kts`	✅	❌
Scala	`.scala`	✅	❌
Lua	`.lua`	✅	❌
Shell	`.sh`, `.bash`, `.zsh`	✅	❌
SQL	`.sql`	✅	❌
HTML	`.html`, `.htm`	✅	❌
CSS	`.css`, `.scss`, `.less`	✅	❌
Markdown	`.md`, `.mdx`	✅	❌
YAML	`.yaml`, `.yml`	✅	❌
JSON	`.json`	✅	❌
TOML	`.toml`	✅	❌
XML	`.xml`	✅	❌

Language Configuration

Enabling/Disabling Languages for Trace

# .grepai/config.yaml
trace:
  enabled_languages:
    - .go
    - .js
    - .ts
    - .jsx
    - .tsx
    - .py
    - .php
    - .rs
    - .c
    - .cpp
    - .cs
    - .java

Excluding Certain Extensions

trace:
  enabled_languages:
    - .go
    # Exclude JavaScript intentionally
    # - .js

  exclude_patterns:
    - "*_test.go"
    - "*.spec.ts"

Language-Specific Tips

Go

trace:
  enabled_languages:
    - .go
  exclude_patterns:
    - "*_test.go"
    - "mock_*.go"
    - "*_mock.go"

Trace accuracy: Excellent. Go's explicit syntax makes tracing very reliable.

JavaScript/TypeScript

trace:
  enabled_languages:
    - .js
    - .jsx
    - .ts
    - .tsx
  exclude_patterns:
    - "*.test.js"
    - "*.spec.ts"
    - "*.d.ts"  # Type declarations

Trace accuracy: Good. Some dynamic patterns may be missed.

Python

trace:
  enabled_languages:
    - .py
  exclude_patterns:
    - "test_*.py"
    - "*_test.py"
    - "conftest.py"

Trace accuracy: Good. Dynamic imports and decorators may be missed.

C/C++

trace:
  enabled_languages:
    - .c
    - .h
    - .cpp
    - .hpp
    - .cc
    - .cxx
  exclude_patterns:
    - "*_test.cpp"

Trace accuracy: Good. Macros and templates may affect accuracy.

Rust

trace:
  enabled_languages:
    - .rs
  exclude_patterns:
    - "**/tests/**"
    - "**/benches/**"

Trace accuracy: Excellent. Rust's explicit syntax aids accurate tracing.

PHP

trace:
  enabled_languages:
    - .php
  exclude_patterns:
    - "*Test.php"
    - "**/tests/**"

Trace accuracy: Good. Magic methods may not be fully traced.

Java

trace:
  enabled_languages:
    - .java
  exclude_patterns:
    - "*Test.java"
    - "**/test/**"

Trace accuracy: Good. Reflection-based calls may be missed.

C#

trace:
  enabled_languages:
    - .cs
  exclude_patterns:
    - "*Tests.cs"
    - "**/Tests/**"

Trace accuracy: Good. Delegates and events may be partially traced.

Multi-Language Projects

For projects with multiple languages:

trace:
  enabled_languages:
    # Backend (Go)
    - .go
    # Frontend (TypeScript)
    - .ts
    - .tsx
    # Shared (SQL, etc.)
    - .sql  # Index only

  exclude_patterns:
    - "*_test.go"
    - "*.spec.ts"

Index vs Trace Explained

Index (Semantic Search)

Works on any text file
Code is chunked and embedded
Enables semantic search
No language-specific parsing required

Trace (Call Graphs)

Requires language-specific parsing
Extracts function definitions and calls
Builds caller/callee relationships
Uses regex (fast) or tree-sitter (precise)

Trace Modes by Language

Language	Fast Mode	Precise Mode
Go	✅	✅
JavaScript	✅	✅
TypeScript	✅	✅
Python	✅	✅
PHP	✅	✅
C/C++	✅	✅
Rust	✅	✅
Zig	✅	✅
C#	✅	✅
Java	✅	✅
Pascal	✅	⚠️ Limited

Adding Custom Extensions

If you have non-standard extensions, they'll be indexed but not traced:

# Custom extension files will be indexed
ignore:
  # Only add patterns for files you DON'T want indexed
  - "*.generated.go"

File Type Detection

GrepAI uses file extensions for detection. It does NOT use:

Shebangs (#!/usr/bin/env python)
File content analysis
.editorconfig

Unsupported Languages (Index Works, No Trace)

These languages can be indexed for semantic search but don't have trace support:

Ruby
Swift
Kotlin
Scala
Elixir
Clojure
Haskell
OCaml
F#
Erlang
R
Julia
Perl
Groovy

Workaround: Use semantic search to find code, then manually trace.

Best Practices

Enable only needed languages: Faster trace building
Exclude test files: Cleaner trace results
Use precise mode for accuracy: When trace results seem incomplete
Match your tech stack: Configure based on your actual languages

Checking Language Support

# Check what's being indexed
grepai status

# Will show file counts by type

Common Issues

❌ Problem: Files not being indexed ✅ Solution: Check file isn't in ignore patterns

❌ Problem: Trace missing for language ✅ Solution: Ensure language is in enabled_languages

❌ Problem: Wrong language detected ✅ Solution: GrepAI uses extensions only; rename files if needed

Output Format

Language support summary:

📚 GrepAI Language Support

Full Support (Index + Trace):
- Go (.go)
- JavaScript (.js, .jsx)
- TypeScript (.ts, .tsx)
- Python (.py)
- PHP (.php)
- C/C++ (.c, .cpp, .h, .hpp)
- Rust (.rs)
- Zig (.zig)
- C# (.cs)
- Java (.java)
- Pascal (.pas, .dpr)

Index Only (No Trace):
- Ruby, Swift, Kotlin, Scala
- Shell scripts, SQL, HTML, CSS
- Config files (YAML, JSON, TOML)
- Documentation (Markdown)

Your config enables trace for:
- .go, .js, .ts, .py

grepai-languages