# What Programming Languages Does OpenClaude Repo-Map Support?

> Discover which programming languages OpenClaude repo-map supports including TypeScript, JavaScript, TSX, and Python. Learn how the repo-map feature works.

- Repository: [Gitlawb/openclaude](https://github.com/Gitlawb/openclaude)
- Tags: getting-started
- Published: 2026-09-06

---

**OpenClaude's repo-map feature supports four programming languages: TypeScript, TSX, JavaScript, and Python**, defined strictly in the `SupportedLanguage` union type within the source code.

The Gitlawb/openclaude repository implements repo-map functionality to enable syntax-aware code navigation and symbol extraction. Understanding what programming languages the OpenClaude repo-map supports helps developers know which file types benefit from intelligent parsing and query-based analysis.

## Supported Languages Overview

The OpenClaude repo-map recognizes source files written in four distinct languages. These languages cover the majority of modern web development and data science workflows:

- **TypeScript** (`.ts` files) — Statically typed JavaScript superset
- **TSX** (`.tsx` files) — TypeScript with JSX support for React components  
- **JavaScript** (`.js`, `.jsx` files) — Dynamic scripting for web applications
- **Python** (`.py` files) — General-purpose language for backend and ML workflows

This specific quartet is hardcoded in the type system, ensuring type safety across the parsing pipeline.

## Language Detection Architecture

### The SupportedLanguage Type Definition

In [`src/context/repoMap/types.ts`](https://github.com/Gitlawb/openclaude/blob/main/src/context/repoMap/types.ts), the supported set is declared as a TypeScript union type:

```typescript
export type SupportedLanguage = 'typescript' | 'tsx' | 'javascript' | 'python';

```

This type definition acts as the single source of truth for all language-specific operations in the repo-map feature. By constraining the type system to these four string literals, OpenClaude ensures compile-time safety when loading parsers or executing queries.

### File Extension to Language Mapping

When processing repository files, [`src/context/repoMap/gitFiles.ts`](https://github.com/Gitlawb/openclaude/blob/main/src/context/repoMap/gitFiles.ts) maps known file extensions to their corresponding `SupportedLanguage` values. The `getLanguageForFile()` function performs this resolution by analyzing the file path and extension.

For example, the function correctly identifies:

- [`src/app/index.ts`](https://github.com/Gitlawb/openclaude/blob/main/src/app/index.ts) → `'typescript'`
- [`components/button.tsx`](https://github.com/Gitlawb/openclaude/blob/main/components/button.tsx) → `'tsx'`  
- [`frontend/main.jsx`](https://github.com/Gitlawb/openclaude/blob/main/frontend/main.jsx) → `'javascript'`
- [`scripts/util.py`](https://github.com/Gitlawb/openclaude/blob/main/scripts/util.py) → `'python'`

Files with extensions outside this supported set return `undefined`, effectively excluding them from repo-map processing.

## Parsing and Query Implementation

### Tree-Sitter Grammar Loading

Once a language is detected, [`src/context/repoMap/parser.ts`](https://github.com/Gitlawb/openclaude/blob/main/src/context/repoMap/parser.ts) loads the appropriate tree-sitter WASM grammar. The `createParser()` function accepts a `SupportedLanguage` parameter and returns a configured parser instance capable of building an abstract syntax tree (AST) for that specific language.

This architecture allows OpenClaude to perform language-specific structural analysis without maintaining separate parsing logic for each grammar. The parser caches grammars efficiently to avoid reloading WASM binaries across multiple file operations.

### Tag Query Definitions

The actual symbol extraction logic resides in [`src/context/repoMap/queries.ts`](https://github.com/Gitlawb/openclaude/blob/main/src/context/repoMap/queries.ts). This module contains bundled tree-sitter query files (such as `typescript-tags.scm`) that define how to identify functions, classes, variables, and imports within each supported language's AST.

These queries are language-specific, allowing the repo-map to extract meaningful context-aware symbols regardless of whether it is parsing a Python module or a TypeScript React component.

## Practical Implementation Example

To leverage the repo-map language detection in your own OpenClaude extensions or modifications, import the core utilities and follow this pattern:

```typescript
import { getLanguageForFile } from '@/context/repoMap/gitFiles.js';
import { createParser } from '@/context/repoMap/parser.js';

async function analyzeSourceFile(path: string, content: string) {
  // Detect language from file extension
  const language = getLanguageForFile(path);
  
  if (!language) {
    throw new Error('Unsupported file type for repo-map analysis');
  }

  // Initialize tree-sitter parser for the detected language
  const parser = await createParser(language);
  const tree = parser?.parse(content);
  
  // Execute repo-map queries on the parsed AST
  // ...symbol extraction and navigation logic here...
}

```

This workflow ensures that only supported languages trigger the parsing pipeline, preventing runtime errors and optimizing performance by skipping irrelevant files.

## Summary

- **Four languages supported**: TypeScript, TSX, JavaScript, and Python, as defined in [`src/context/repoMap/types.ts`](https://github.com/Gitlawb/openclaude/blob/main/src/context/repoMap/types.ts).
- **Type-safe definitions**: The `SupportedLanguage` union type prevents invalid language values from propagating through the codebase.
- **Extension-based detection**: `getLanguageForFile()` in [`src/context/repoMap/gitFiles.ts`](https://github.com/Gitlawb/openclaude/blob/main/src/context/repoMap/gitFiles.ts) maps file paths to language identifiers.
- **Tree-sitter integration**: `createParser()` in [`src/context/repoMap/parser.ts`](https://github.com/Gitlawb/openclaude/blob/main/src/context/repoMap/parser.ts) dynamically loads the correct WASM grammar for each supported language.
- **Query-driven analysis**: Language-specific symbol extraction is handled through dedicated `.scm` query files in [`src/context/repoMap/queries.ts`](https://github.com/Gitlawb/openclaude/blob/main/src/context/repoMap/queries.ts).

## Frequently Asked Questions

### What programming languages does OpenClaude repo map support?

OpenClaude repo-map supports TypeScript, TSX, JavaScript, and Python. This set is explicitly defined as the `SupportedLanguage` union type in [`src/context/repoMap/types.ts`](https://github.com/Gitlawb/openclaude/blob/main/src/context/repoMap/types.ts), which constrains all language-specific operations throughout the codebase.

### How does OpenClaude detect the language of a source file?

OpenClaude uses the `getLanguageForFile()` function exported from [`src/context/repoMap/gitFiles.ts`](https://github.com/Gitlawb/openclaude/blob/main/src/context/repoMap/gitFiles.ts) to analyze file extensions and map them to `SupportedLanguage` values. This function returns `'typescript'`, `'tsx'`, `'javascript'`, or `'python'` based on the file path, or `undefined` for unsupported extensions.

### Where are the tree-sitter grammars loaded in OpenClaude?

Tree-sitter grammars are loaded in [`src/context/repoMap/parser.ts`](https://github.com/Gitlawb/openclaude/blob/main/src/context/repoMap/parser.ts) via the `createParser()` function. This module dynamically imports the appropriate WASM grammar for the requested `SupportedLanguage` and maintains a cache to optimize performance across multiple parsing operations.

### Can I extend OpenClaude to support additional programming languages?

Adding support for additional languages would require modifying the `SupportedLanguage` type in [`src/context/repoMap/types.ts`](https://github.com/Gitlawb/openclaude/blob/main/src/context/repoMap/types.ts), updating the extension mapping logic in [`src/context/repoMap/gitFiles.ts`](https://github.com/Gitlawb/openclaude/blob/main/src/context/repoMap/gitFiles.ts), and providing corresponding tree-sitter WASM grammars and tag query files in the parser and queries modules. The current architecture is designed around the four built-in languages, so extensions would need to maintain type safety throughout the parsing pipeline.