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

yaml

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

Excluding Certain Extensions

yaml

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

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

Language-Specific Tips

Go

yaml

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

yaml

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

yaml

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

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

C/C++

yaml

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

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

Rust

yaml

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

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

PHP

yaml

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

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

Java

yaml

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

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

C#

yaml

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:

yaml

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:

yaml

# 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

bash

# 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:

code

📚 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