New: 98,000+ skills indexed from GitHub repos with 100+ stars · every skill safety-checkedBrowse top skillsTop skills
Esc to closeBrowse all skills
Submit a skillBrowse skills
Submit a skillBrowse skills

Agent skill

Pure Lsp Check

by finos in finos/legend-engine

Compiles/checks a single .pure file against the already-running Legend Pure LSP bridge and reports diagnostics (errors/warnings) in under a second, as a fast alternative to a full mvn test/mvn…

Apache-2.0Auto-check passed

Install Pure Lsp Check

skills CLI
$ npx skills add finos/legend-engine --skill pure-lsp-check -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install finos/legend-engine pure-lsp-check --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/finos/legend-engine.git skills-src && mkdir -p .claude/skills && cp -r skills-src/plugins/pure-dev/skills/pure-lsp-check .claude/skills/pure-lsp-check && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Facts

Skill name
pure-lsp-check
GitHub stars
113
Token cost
~1.4k tokens
SKILL.md length
696 words
Files
1
Skills in repo
15
Repo updated
First seen
Licence
Apache-2.0

At a glance

Compiles/checks a single .pure file against the already-running Legend Pure LSP bridge and reports diagnostics (errors/warnings) in under a second, as a fast alternative to a full mvn test/mvn…

  • The user is editing .pure files and wants to know if they compile
  • SKILL.md covers Usage, Checking several files that… and Things worth knowing
  • Instructions only: no scripts, shell commands, URLs or credentials in SKILL.md
  • Asks does this Pure file compile

What it does

Pure Lsp Check is an agent skill from finos/legend-engine. Compiles/checks a single .pure file against the already-running Legend Pure LSP bridge and reports diagnostics (errors/warnings) in under a second, as a fast alternative to a full mvn test/mvn compile cycle while iterating on Pure source in legend-pure. Use whenever the user is editing .pure files and wants to know if they compile, asks 'does this Pure file compile', 'check this .pure file', 'validate this Pure code', or wants fast type/syntax feedback without running the full Maven build.

Its SKILL.md is about 1.4k tokens, which your agent loads only when the skill is triggered. It is a single SKILL.md file with no bundled scripts.

The licence is Apache-2.0.

When your agent uses it

  • The user is editing .pure files and wants to know if they compile
  • Asks does this Pure file compile
  • Check this .pure file
  • Validate this Pure code

Example prompts

  • “does this Pure file compile”
  • “check this .pure file”
  • “validate this Pure code”
  • “/pure-lsp-check”

What it can do on your machine

Read from SKILL.md and the folder at commit e60ab67. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    No scripts in the folder and no shell commands in SKILL.md (its code samples are json and bash).

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    No URLs in SKILL.md.

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names no API keys, tokens, secrets or passwords.

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

Pure Lsp Check loads about 1.4k tokens when it runs. Until then it costs about 128 tokens; SKILL.md has 696 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~128
When it runs · the whole SKILL.md, loaded when a task matches
~1.4k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check passed

The automated check found no risky patterns in SKILL.md.

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); files beside SKILL.md are not scanned.

SKILL.md

The full file from finos/legend-engine at commit e60ab67, republished under its Apache-2.0 licence (© finos). 696 words, ~1,424 tokens.

Download SKILL.mdSave it as .claude/skills/pure-lsp-check/SKILL.md (or your agent's skills folder).
name
pure-lsp-check
description
Compiles/checks a single .pure file against the already-running Legend Pure LSP bridge and reports diagnostics (errors/warnings) in under a second, as a fast alternative to a full `mvn test`/`mvn compile` cycle while iterating on Pure source in legend-pure. Use whenever the user is editing .pure files and wants to know if they compile, asks 'does this Pure file compile', 'check this .pure file', 'validate this Pure code', or wants fast type/syntax feedback without running the full Maven build.

Compile-check a .pure file via the LSP bridge

Requires a running bridge (pure-lsp health) — and never curl it, pure-lsp is the only reliable client. Both rules, and the port-discovery behaviour, are in references/lsp-devloop-usage-rules.md.

Usage

bash
pure-lsp check <path/to/file.pure>
  • Pass - instead of a path to check content from stdin.
  • Add --port <N> (or set PURE_LSP_PORT) to target a specific bridge. Without it, pure-lsp finds a running bridge automatically (via the /tmp/pure_lsp_server_<port>.json sidecar each bridge writes), falling back to 8991.
  • Add --uri <uri> to override the LSP document URI if you need a specific one (rarely needed — the default file://<absolute path> is fine even for scratch files that don't map to a real workspace repo).

The command exits 1 if any diagnostic has severity: 1 (error), 0 if clean — usable directly in a shell conditional. Output looks like:

json
{
  "uri": "file:///tmp/Example.pure",
  "diagnostics": [
    {
      "range": {"start": {"line": 2, "character": 5}, "end": {"line": 2, "character": 20}},
      "severity": 1,
      "message": "TotallyNotAType has not been defined!"
    }
  ]
}

An empty diagnostics array means it compiled cleanly.

Checking several files that reference each other: use check-many, not a loop of check

If you're validating a batch of changed files and any of them reference types/functions defined in another file in the same batch, don't just call check on each one in a loop — plain check goes through textDocument/didOpen/didChange, which the LSP compiles immediately and independently as each one arrives, with no awareness of files pushed moments later. A file checked before its dependency is pushed will falsely report "X has not been defined."

bash
pure-lsp check-many FileA.pure FileB.pure FileC.pure

check-many instead calls the server's legend/checkBatch, which applies every file's content to the runtime and compiles once, atomically — not per file, and not client-side pushed twice to route around ordering. Argument order genuinely doesn't matter: the compiler sees the whole batch at once. Response shape:

json
{"success": true, "modifiedFiles": ["file:///.../FileA.pure", "..."]}

or, on failure:

json
{"success": false, "error": "...", "errorUri": "file:///.../FileC.pure", "errorDiagnostics": [...]}

The trade-off for the efficiency of a single compile: on success, every file in the batch (and anything else transitively affected) is guaranteed clean — modifiedFiles lists all of them. On failure, the whole batch is rolled back (nothing was actually applied) and you get exactly one error, attributed to its real file via errorUri (with full structured errorDiagnostics — range/severity/code — for that one file), not a per-file breakdown across everything you passed. If you need to know about every broken file in a batch rather than just the first one the compiler hits, fix the reported one and re-run check-many to find the next. Exits 1 on failure.

Show full SKILL.md (315 more words)Show less

Things worth knowing

  • The first check call on a given URI is a didOpen; every call after that on the same URI is a didChange (the LSP protocol requires this distinction) — pure-lsp handles the transition automatically, you don't need to track which call number you're on.
  • This only compiles the file(s) you've pushed via check (plus whatever else is already loaded in the session) — it does not run anything. To actually execute a function, follow up with the pure-lsp-go skill.
  • A check/check-many target must be a real file under one of the bridge's configured repo roots (or fed as literal content via check -). A .pure file that exists on disk somewhere else — e.g. a scratch file under /tmp — is silently ignored by the LSP (it isn't part of any registered module), so you get back {"diagnostics": []} (looks clean) with exit 0 even for code that doesn't compile at all — nothing was actually checked. For ad hoc scratch content that isn't part of a real module, pipe it through stdin (check -) instead of writing it to a path outside the workspace — stdin has no on-disk identity, so the LSP compiles it for real as a scratch source.
  • If diagnostics mention a type/class from elsewhere in the codebase that "has not been defined", double check it isn't just missing from what's been pushed into this particular session yet — the bridge only knows about files under its configured workspace root(s)/classpath plus whatever you've explicitly checked.
  • Never pass a .legend file to check/check-many. .legend files are plain-text fixture resources loaded at runtime via the Pure readFile(...) function inside a test — they are not Pure compilation units the LSP indexes. Passing one throws "Invalid source id" and knocks the whole runtime into a recovering state (see pure-lsp-status's troubleshooting note). Only pass .pure source files here; verify a .legend fixture indirectly by running the test/go() function that reads it via pure-lsp-go.

© finos, Apache-2.0. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

Just SKILL.md in plugins/pure-dev/skills/pure-lsp-check of finos/legend-engine.

Open the folder on GitHubat commit e60ab67

Compare with similar skills

Pure Lsp Check next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

Pure Lsp Check compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Pure Lsp Check this skillfinos/legend-engine113—~1.4kAutomated safety check: PassApache-2.0
Lspcode-yeongyu/oh-my-openagent70k—~304Automated safety check: PassCustom licence
Compile Knowledgesickn33/agentic-awesome-skills47k1 repos~2.3kAutomated safety check: PassMIT
Compileratopile/atopile4k—~1kAutomated safety check: PassMIT
Lsp Setupgithub/awesome-copilot40k1 repos~996Automated safety check: PassMIT
Lspatopile/atopile4k—~594Automated safety check: PassMIT

Similar skills

  • Lsp

    code-yeongyu/oh-my-openagent

    A skill your agent uses when Codex needs language-server diagnostics, definitions, references, symbols, or rename safety checks in the current workspace.

    70k GitHub stars~304 tokensUpdated today
    Auto-check passed

  • Compile Knowledge

    sickn33/agentic-awesome-skills

    Compile durable, non-obvious findings into an interlinked markdown knowledge store — atomic files, [[wiki-links]], a maintained index — so an agent gets smarter across sessions instead of relearning…

    47k GitHub starsUsed in 1 repo~2.3k tokens
    Auto-check passed

  • Compiler

    atopile/atopile

    How the atopile compiler builds and links TypeGraphs from .ato (ANTLR front-end → AST → TypeGraph → Linker → DeferredExecutor), plus the key invariants and test entrypoints.

    4k GitHub stars~1k tokensUpdated 4 mo ago
    Frontend & DesignAuto-check passed

  • Lsp Setup

    github/awesome-copilot

    Official

    Enable code intelligence (go-to-definition, find-references, hover, type info) for any programming language by installing and configuring an LSP server for Copilot CLI.

    40k GitHub starsUsed in 1 repo~996 tokens
    DevelopmentAuto-check passed

  • Lsp

    atopile/atopile

    How the atopile Language Server works (pygls), how it builds per-document graphs for completion/hover/defs, and the invariants for keeping it fast and crash-proof.

    4k GitHub stars~594 tokensUpdated 4 mo ago
    Auto-check passed

  • Lsp

    LuisaGroup/LuisaCompute

    clangd LSP over HTTP for C++ syntax checks and symbol navigation in LuisaCompute sources.

    1.1k GitHub stars~758 tokensUpdated yesterday
    Auto-check passed

More from finos/legend-engine

All 15 skills in this repo

  • Pure Backend Start

    finos/legend-engine

    Starts (or confirms) the standalone legend-engine backend - engine Server + H2 + local metadata server on fixed ports 9095/9092 - so a Pure LSP started with -Dlegend.test.

    113 GitHub stars~1.2k tokensUpdated today
    Auto-check passed

  • Pure Chain Update

    finos/legend-engine

    Procedure for git-syncing and rebuilding a local legend-pure + legend-engine checkout, in dependency order, with pinned dependency versions resynced.

    113 GitHub stars~1.8k tokensUpdated today
    Auto-check passed

  • Pure Code Style

    finos/legend-engine

    Reformats a .pure file (or a block of Pure code) to a consistent house style: 2-space indentation with no column-aligned hanging indents, tight colons in type annotations, spaced pipes on…

    113 GitHub stars~1.6k tokensUpdated today
    Auto-check passed

  • Pure Lsp Connect

    finos/legend-engine

    Attaches the pure-lsp HTTP bridge to an LSP daemon that is ALREADY running (e.g.

    113 GitHub stars~1.3k tokensUpdated today
    Auto-check passed

  • Pure Lsp Execute

    finos/legend-engine

    Runs exactly ONE existing Pure function by path (signature, mangled id or bare path) through the running Legend Pure LSP bridge, without a go() wrapper, and returns its typed value in returnValue.

    113 GitHub stars~883 tokensUpdated today
    Auto-check passed

  • Pure Lsp Execute Parallel

    finos/legend-engine

    Runs 2 to 30 Pure functions or tests concurrently on the warm LSP daemon via pure-lsp execute-parallel, or every test in a package or .pure file with --package/--source.

    113 GitHub stars~927 tokensUpdated today
    Auto-check passed

Questions about Pure Lsp Check

What does Pure Lsp Check do?

Compiles/checks a single .pure file against the already-running Legend Pure LSP bridge and reports diagnostics (errors/warnings) in under a second, as a fast alternative to a full mvn test/mvn…. Pure Lsp Check is an agent skill from finos/legend-engine.pure file against the already-running Legend Pure LSP bridge and reports diagnostics (errors/warnings) in under a second, as a fast alternative to a full mvn test/mvn compile cycle while iterating on Pure source in legend-pure.

When should I use Pure Lsp Check?

Pure Lsp Check fits situations like: the user is editing .pure files and wants to know if they compile; asks does this Pure file compile; check this .pure file; validate this Pure code.

How do I install Pure Lsp Check in Claude Code?

Run `npx skills add finos/legend-engine --skill pure-lsp-check -a claude-code`. Or copy the skill folder (plugins/pure-dev/skills/pure-lsp-check in finos/legend-engine) into .claude/skills/pure-lsp-check in your project. Claude Code loads it when a task matches its description.

How do I install Pure Lsp Check in Codex?

Run `npx skills add finos/legend-engine --skill pure-lsp-check -a codex`. Or copy the skill folder (plugins/pure-dev/skills/pure-lsp-check in finos/legend-engine) into .agents/skills/pure-lsp-check in your project. Codex loads it when a task matches its description.

Can I use Pure Lsp Check in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add finos/legend-engine --skill pure-lsp-check -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/pure-lsp-check, .gemini/skills/pure-lsp-check, .github/skills/pure-lsp-check and .opencode/skills/pure-lsp-check in your project.

What does Pure Lsp Check need to run?

SKILL.md names no scripts, command-line tools or credentials: Pure Lsp Check is instructions for the agent only.

Does Pure Lsp Check access the network?

SKILL.md contains no URLs. Any network use would come from the scripts or tools the agent runs. This is read from the text; nothing was executed.

Is Pure Lsp Check safe to install?

Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. Review the folder before installing.

What licence does Pure Lsp Check use?

Pure Lsp Check is published under the Apache-2.0 licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Pure Lsp Check use?

About 1.4k tokens (SKILL.md is roughly 5.7k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full.

What are the alternatives to Pure Lsp Check?

Skills that share tags, products or a category with Pure Lsp Check: Lsp (code-yeongyu/oh-my-openagent, 70k stars), Compile Knowledge (sickn33/agentic-awesome-skills, 47k stars), Compiler (atopile/atopile, 4k stars) and Lsp Setup (github/awesome-copilot, 40k stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Pure Lsp Check?

finos (a GitHub organization) maintains it in finos/legend-engine, which has 113 GitHub stars. The repository holds 15 skills in this directory. The repository was last updated on October 10, 2026.

Source: finos/legend-engine on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.