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