```toml

language-pack.toml¶

Language names to pre-download¶

languages = ["python", "javascript", "typescript", "rust"]

Optional: language groups to pre-download¶

groups = ["web", "systems", "data"]¶

Optional: custom cache directory¶

cache_dir = ".cache/parsers"¶

```

```bash

Create language-pack.toml with interactive prompts¶

ts-pack init

Create with specific languages¶

ts-pack init --languages python,javascript,typescript,rust

Specify custom cache directory¶

ts-pack init --cache-dir ./local-cache --languages python,rust ```

```python from tree_sitter_language_pack import init, configure, get_parser

Pre-download specific languages¶

init(languages=["python", "javascript", "rust"])

Now use the library¶

parser = get_parser("python") tree = parser.parse(b"x = 1") ```

```python from tree_sitter_language_pack import configure, get_parser

Set custom cache before the first parse¶

configure(cache_dir="/opt/ts-pack-cache")

Now all future downloads use this cache¶

parser = get_parser("python") ```

```python from tree_sitter_language_pack import init

Download by language group¶

init(groups=["web"]) # JavaScript, TypeScript, HTML, CSS init(groups=["systems"]) # C, C++, Rust, Go init(groups=["data"]) # Python, R, SQL, JSON

Combine languages and groups¶

init( languages=["python"], groups=["web", "systems"] ) ```

```python from tree_sitter_language_pack import PackConfig, init from pathlib import Path

Load from language-pack.toml¶

config = PackConfig.from_toml_file(Path("language-pack.toml"))

if config.languages: init(languages=config.languages) if config.groups: init(groups=config.groups) ```

```python from tree_sitter_language_pack import PackConfig, init

Search for language-pack.toml in current dir and parents¶

config = PackConfig.discover()

if config: print(f"Found config with languages: {config.languages}") if config.languages: init(languages=config.languages) else: print("No configuration found, using defaults") ```

```typescript import { init, getParser } from "@kreuzberg/tree-sitter-language-pack";

// Pre-download specific languages await init({ languages: ["python", "javascript", "rust"] });

// Now use the library const parser = await getParser("python"); const tree = parser.parse("x = 1"); ```

```typescript import { configure, getParser } from "@kreuzberg/tree-sitter-language-pack";

// Set custom cache before the first parse await configure({ cacheDir: "/opt/ts-pack-cache" });

// Now all future downloads use this cache const parser = await getParser("python"); ```

```typescript import { init } from "@kreuzberg/tree-sitter-language-pack";

// Download by language group await init({ groups: ["web"] }); // JS, TS, HTML, CSS await init({ groups: ["systems"] }); // C, C++, Rust, Go await init({ groups: ["data"] }); // Python, R, SQL

// Combine languages and groups await init({ languages: ["python"], groups: ["web", "systems"] }); ```

```rust use ts_pack_core::PackConfig; use std::path::Path;

// Create configuration programmatically let config = PackConfig { cache_dir: Some(Path::new("/opt/cache").to_path_buf()), languages: Some(vec![ "python".to_string(), "rust".to_string(), "typescript".to_string(), ]), groups: None, };

// Load from file let config = PackConfig::from_toml_file(Path::new("language-pack.toml"))?;

// Discover configuration if let Some(config) = PackConfig::discover() { println!("Found languages: {:?}", config.languages); } ```

```bash

Override cache directory¶

export TSLP_CACHE_DIR="/tmp/ts-pack-cache"

Specify config file location¶

export TSLP_CONFIG="/path/to/language-pack.toml"

Enable verbose output¶

export TSLP_VERBOSE=1

Disable color output¶

export TSLP_NO_COLOR=1

python -c "from tree_sitter_language_pack import get_parser; parser = get_parser('python')" ```

```bash

Override cache directory¶

ts-pack parse main.py --cache-dir /tmp/ts-pack-cache

Specify config file¶

ts-pack parse main.py --config /path/to/language-pack.toml

Verbose output¶

ts-pack parse main.py --verbose

Disable colors¶

ts-pack parse main.py --no-color ```

```yaml name: CI

on: [push, pull_request]

jobs: analyze: runs-on: ubuntu-latest steps: - uses: actions/checkout@v4

  - name: Install ts-pack
    run: |
      brew install kreuzberg-dev/tap/ts-pack

  - name: Download languages
    run: ts-pack download

  - name: Analyze code
    run: |
      ts-pack process src/ --structure --format json > analysis.json
      jq '.structure | length' analysis.json

```

```yaml name: CI

on: [push, pull_request]

jobs: analyze: runs-on: ubuntu-latest steps: - uses: actions/checkout@v4

  - name: Install ts-pack
    run: brew install kreuzberg-dev/tap/ts-pack

  - name: Cache parsers
    uses: actions/cache@v4
    with:
      path: ~/.cache/tree-sitter-language-pack
      key: ${{ runner.os }}-ts-pack-${{ hashFiles('language-pack.toml') }}
      restore-keys: |
        ${{ runner.os }}-ts-pack-

  - name: Download languages
    run: ts-pack download

  - name: Analyze code
    run: ts-pack process src/ --all --format json > analysis.json

```

```yaml name: Test

on: [push]

jobs: test: runs-on: ${{ matrix.os }} strategy: matrix: os: [ubuntu-latest, macos-latest, windows-latest] language: [python, javascript, rust, go] steps: - uses: actions/checkout@v4

  - name: Install ts-pack
    run: cargo install ts-pack

  - name: Download language
    run: ts-pack download ${{ matrix.language }}

  - name: Parse samples
    run: ts-pack parse examples/${{ matrix.language }}/sample.*

```

```dockerfile FROM python:3.11-slim

Install ts-pack from source¶

RUN pip install tree-sitter-language-pack

Your code¶

COPY . /app WORKDIR /app

Run your analysis¶

RUN python analyze.py ```

```dockerfile FROM python:3.11-slim

Install ts-pack¶

RUN pip install tree-sitter-language-pack

Pre-download languages (bakes into image)¶

RUN ts-pack download --all

Your code¶

COPY . /app WORKDIR /app

Parsing is now offline¶

RUN python analyze.py ```

```dockerfile FROM ubuntu:24.04

RUN apt-get update && apt-get install -y \ python3 python3-pip \ && rm -rf /var/lib/apt/lists/*

RUN pip install tree-sitter-language-pack

Cache will be mounted as a volume¶

WORKDIR /app

ENTRYPOINT ["ts-pack", "process"] ```

Run with: bash docker run --rm \ -v "$PWD:/app" \ -v "$HOME/.cache/ts-pack:/root/.cache/tree-sitter-language-pack" \ ts-pack-image src/main.py --structure

```bash

Check cache location¶

ts-pack cache-dir

Try downloading verbosely¶

ts-pack download python --verbose

Check network access¶

curl -I https://releases.kreuzberg.dev/tree-sitter-language-pack/manifest.json ```

• Offline mode: Pre-download languages on a machine with network access, copy cache to offline machine
• Custom mirror: Set TSLP_CACHE_DIR to a pre-populated cache
• Docker: Use a Docker image with languages pre-baked