Skip to main content
← CLI Reference

travsr lang

Install and manage per-language semantic analysis tools: plugins that add call edges, type resolution, and cross-module references on top of the always-on Tree-sitter structural parsing.

How language analysis works​

Your source files
.ts · .rs · .py · .go · .java · …
on every commit
▼
Structural parsing
Tree-sitter · always on · all languages
functions
classes
imports
+
Semantic analysis
language tool · opt-in · per language
call edges
type resolution
cross-module refs
nodes + edges
▼
travsr-store
SQLite WAL.travsr/graph.db
Kythe VNamesnode identity

Language tool tiers​

Built-in
No install required · always active
TypeScriptbuilt-in
JavaScriptbuilt-in
Rustbuilt-in
Pythonbuilt-in
Standard
Install with one command · no network access during indexing
Goscip-go
Rubyscip-ruby
PHPscip-php
Swiftswift-index-emitter
Objective-CmacOS only
Native IPC
Install with one command · no network access · resource limits instead of sandbox-exec on macOS
C++scip-clang
Cscip-clang
Dartdart-index-emitter
Elevated
Access granted automatically · downloads build deps during indexing
Javascip-java
Kotlinkotlin-language-server
C#scip-dotnet
Scalasbt

Subcommands​

SubcommandDescription
travsr lang list [<lang>]Show every supported language, or just one, and whether full analysis is available. Aliased as travsr lang status
travsr lang detectScan this repo, detect its languages, and set up full analysis for them
travsr lang install <lang>Download the analyzer and turn on full analysis for the language
travsr lang add <lang>Older name for install
travsr lang remove <lang>Turn off full analysis for a language
travsr lang allow-unsandboxed <lang>Windows only: permit an analyzer that cannot run inside the isolation layer to run with your own privileges

travsr lang list​

travsr lang list output
travsr lang list [<language>] [--json]

Prints a table of every language (or only <language>, for example travsr lang status typescript), whether full analysis is on for the repository you are standing in, what the analyzer needs on this machine, and whether it is available. --json prints a JSON array instead. Trimmed:

LANGUAGE THIS REPO PREREQUISITES STATUS
------------------------------------------------------------------------------------
typescript always on Node.js active
javascript always on Node.js active
rust always on Rust toolchain (cargo) active
go enabled Go toolchain active
python always on Node.js (runs the bundled Python analyzer) active
java enabled JDK, Maven or Gradle active
scala enabled JDK, sbt active
cpp enabled compile_commands.json active
dart enabled pub get (resolved deps) active

STATUS and THIS REPO answer different questions, which is why both are there. STATUS is about this machine: is the analyzer present at all. THIS REPO is about the repository in front of you: is full analysis turned on for it (always on, enabled or not enabled). PREREQUISITES names what the analyzer needs from your toolchain. A language can be installed machine-wide and still be off here. When an analyzer is missing, STATUS reads partial and THIS REPO reads not enabled, even for a built-in language such as Rust; the remedy is travsr lang install <language>, not a per-repo step.

travsr init, travsr status, the MCP notes and the VS Code extension all report a language's readiness from one shared check, so they cannot disagree: ready, setting_up (something travsr init finishes itself), needs_toolchain (install the named toolchain, then rerun travsr init), unsupported_os, or failed. Each non-ready line ends with one concrete next step.

Earlier versions printed PACKAGE and SANDBOX columns. Both are gone: the npm package names no longer install anything, and the sandbox tier was an internal detail that did not tell you whether the language worked.


travsr lang install​

travsr lang install <language> [--reinstall] [--no-interactive] [--yes]
[--skip-wrapper] [--corpus <id>] [--version <tag>]

Downloads the language's analyzer into ~/.travsr/bin/ and turns on full analysis for it.

Go is the exception: travsr lang install go runs go install github.com/scip-code/scip-go/cmd/scip-go@latest, so scip-go lands where the Go toolchain puts it ($GOBIN, or $GOPATH/bin, by default ~/go/bin). Travsr looks there as well as on PATH.

A tool unpacked from a zip archive keeps its execute bit (masked to 0755, so no archive can plant a setuid, setgid, sticky or world-writable file). If Kotlin was installed with an earlier version and reports "produced no symbols", rerun travsr lang install kotlin to replace its launcher with an executable one.

Running it inside a repository is itself the consent signal for that repository, so it also turns the language on here. There is no separate per-repo step; --corpus exists only for the rare case of targeting another repository identity.

Java, Kotlin, Scala, and C# reach the network while indexing to resolve build dependencies. Their elevated access is granted automatically for local use, so no approval step is required. Earlier versions asked for an approver's GitHub handle, a justification, and a host allowlist, and travsr lang approve recorded that non-interactively. Both are gone. The runtime isolation policy is unchanged; only the human approval moment was removed.

Flags​

FlagDescription
--reinstallRe-download and overwrite the analyzer even if it is already installed
--no-interactiveSkip all interactive prompts, for CI and scripting
--yesAuto-confirm the analyzer download
--skip-wrapperOnly turn the language on in config; do not download its analyzer
--corpus <id>Advanced: turn on full analysis for a specific repository identity instead of the current one
--version <tag>Pin the downloaded analyzer to a specific release instead of the latest. Applies to analyzers fetched from GitHub releases; this is the analyzer's own tag (for example v0.12.3 for scip-java), not a Travsr version

travsr lang add <language> [--corpus <id>] is the older name for install and takes only --corpus.


travsr lang detect​

travsr lang detect output
travsr lang detect [--yes]

Scans the repository, works out which languages it contains, and sets up full analysis for them. It prints a numbered list with each language's status, then prompts for which ones to install. Without a terminal it prints the list and stops, so pass --yes in scripts and from the editor extension to install every detected language. Trimmed:

Detected languages in this repo:

[1] typescript (.ts, .tsx) active
[2] javascript (.js, .jsx, .mjs, .cjs) active
[3] rust (.rs) active
[4] go (.go) active

Which to install? (numbers separated by commas, 'a' for all, 'q' to quit):

travsr lang remove​

travsr lang remove <language>

Turns off full analysis for a language. The repository falls back to the Tree-sitter structural graph for it.


travsr lang allow-unsandboxed​

travsr lang allow-unsandboxed <language> [--granted-by <who>] [--yes]
travsr lang allow-unsandboxed <language> --revoke

Windows only. Java (Gradle) and Scala (sbt) fork worker processes that cannot run inside the Windows isolation layer, so on Windows they are skipped rather than run. This records a one-time permission to run that analyzer with your own privileges instead.

The permission is per language and machine-local, never stored in the repo, and the reindex on commit honours it with no extra flag. It requires an interactive confirmation or --yes; it will not grant silently when there is neither. The unsandboxed child starts from a cleared environment with an OS-essentials allowlist, so tokens such as GITHUB_TOKEN, AWS_*, SSH_*, and NPM_TOKEN never reach Gradle or sbt.

macOS and Linux never need this.

VS Code​

The Health panel in the VS Code extension (Travsr: Health) shows the same per-language state alongside the graph stats. It replaced the separate Languages panel in extension 0.12.0. See Health Panel.

Sidecar versions​

travsr lang list ends with the shared sidecars: block, reporting the installed version of each external analyzer and whether it meets the version Travsr requires.

sidecars:
travsr-embed 1.6.0 ok
scip-java 0.13.1 ok
scip-clang 0.4.0 ok

A tool below its required version is refused at spawn rather than left to fail deeper, and the line names the reinstall command that fixes it. See travsr status for the full set of states.

C and C++ need a compile database​

scip-clang cannot analyze a translation unit it does not know the compile flags for, so C and C++ semantic indexing requires a compile_commands.json at the repo root. Generate one with bear -- make, or with CMake's CMAKE_EXPORT_COMPILE_COMMANDS.

Worth knowing, because it looks like Travsr failing when it is not: a compile database missing system include paths produces partial output. scip-clang indexes what it can and stays quiet about the rest, so a file that includes a standard header may come back with fewer references than it actually has. If semantic results look thin for C or C++, check that the compile database is the one your build system generated rather than a hand-written stub.