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 Classpath

by finos in finos/legend-engine

Computes and caches the engine-scale Pure classpath (via Maven dependency:build-classpath) for any pure-bearing project registered in config/projects.json - legend-pure, legend-engine, or a project…

Apache-2.0Auto-check passed

Install Pure Lsp Classpath

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

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

GitHub CLI
$ gh skill install finos/legend-engine pure-lsp-classpath --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-classpath .claude/skills/pure-lsp-classpath && 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-classpath
GitHub stars
112
Token cost
~1.5k tokens
SKILL.md length
437 words
Files
1
Skills in repo
15
Repo updated
First seen
Licence
Apache-2.0

At a glance

Computes and caches the engine-scale Pure classpath (via Maven dependency:build-classpath) for any pure-bearing project registered in config/projects.json - legend-pure, legend-engine, or a project…

  • SKILL.md covers The project registry…, Two helpers, How the classpath is chosen… and Launching the LSP for a…, plus 2 more sections
  • Calls mvn and git

What it does

Pure Lsp Classpath is an agent skill from finos/legend-engine. Computes and caches the engine-scale Pure classpath (via Maven dependency:build-classpath) for any pure-bearing project registered in config/projects.json - legend-pure, legend-engine, or a project you've layered on top via PUREDEVEXTRAPROJECTSJSON - and resolves that project's dependency-ordered --repo-root set. Use before the first engine-scale LSP start in a repo, when the cached classpath is stale after pulling or rebuilding, when engine-scale boot fails on missing classpath entries, or when you need…

Its SKILL.md is about 1.5k 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.

Example prompts

  • “Use the pure-lsp-classpath skill to compute and caches the engine-scale Pure classpath (via Maven dependency:build-classpath) for any pure-bearing…”
  • “/pure-lsp-classpath”

What it can do on your machine

Read from SKILL.md and the folder at commit 00108b7. 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

    Shell commands in SKILL.md call:

    • mvn
    • git

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

  • Network

    No URLs in SKILL.md. Its commands use git, which can reach the network depending on how they are called.

    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 Classpath loads about 1.5k tokens when it runs. Until then it costs about 156 tokens; SKILL.md has 437 words of instructions outside code blocks.

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

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 00108b7, republished under its Apache-2.0 licence (© finos). 437 words, ~1,496 tokens.

Download SKILL.mdSave it as .claude/skills/pure-lsp-classpath/SKILL.md (or your agent's skills folder).
name
pure-lsp-classpath
description
Computes and caches the engine-scale Pure classpath (via Maven dependency:build-classpath) for any pure-bearing project registered in config/projects.json - legend-pure, legend-engine, or a project you've layered on top via PURE_DEV_EXTRA_PROJECTS_JSON - and resolves that project's dependency-ordered --repo-root set. Use before the first engine-scale LSP start in a repo, when the cached classpath is stale after pulling or rebuilding, when engine-scale boot fails on missing classpath entries, or when you need repo-roots for a project with dependencies. Provides pure-lsp-classpath and pure-lsp-roots.

Compute the classpath + repo-roots for any Pure project

The engine-scale LSP daemon needs (a) the full classpath of jars for the project you're working in plus everything it depends on, and (b) the right --repo-roots so your edits are read from source. Both are machine- and project-specific, so nothing can be a shipped file. This skill computes and caches them for any pure-bearing project, respecting the dependency graph between them.

The project registry (dependency DAG)

config/projects.json declares the pure-bearing projects and their dependsOn edges. Current graph:

legend-pure  ←  legend-engine
  • legend-pure (base, platform*), legend-engine (core*, → legend-pure)

pure-lsp-classpath --list / pure-lsp-roots --list prints the registry + your checkout paths. Add or adjust projects by editing config/projects.json (name, root/rootEnv, dependsOn, module), or layer extra projects on top without editing it via PURE_DEV_EXTRA_PROJECTS_JSON (os.pathsep-separated list of files shaped like config/projects.json; an extra entry's dependsOn may reference legend-engine/legend-pure by name).

Two helpers

bash
# Classpath (compute-if-stale, cached per project under ~/.cache/pure-dev/):
pure-lsp-classpath [project]            # print cache path, computing if missing/stale
pure-lsp-classpath [project] --force    # force recompute
pure-lsp-classpath [project] --path     # print cache path only (never compute)
pure-lsp-classpath [project] --module M # override the Maven module to build from

# Repo-roots (dependency-ordered):
pure-lsp-roots [project]                # DEFAULT: --repo-root for the FULL transitive dep chain
                                         #   (target + everything it depends on - edit anywhere)
pure-lsp-roots [project] --source X     # EXACT custom set instead of the default (repeatable;
                                         #   target is always included) - everything else in the
                                         #   chain then resolves from the classpath jars, e.g.
                                         #   `pure-lsp-roots legend-engine --source legend-engine`
                                         #   source-roots only legend-engine, leaving legend-pure to
                                         #   load from jars.
pure-lsp-roots [project] --all-source   # no-op alias for the default (kept for explicitness)
pure-lsp-roots [project] --json         # root paths as a JSON array

project defaults to $PURE_DEV_PROJECT, else the project inferred from your current directory, else you pass it explicitly. Checkout paths come from each project's rootEnv (e.g. $LEGEND_ENGINE_ROOT) or $HOME/<root>.

How the classpath is chosen (respecting the DAG)

The classpath is built from the highest project in the target's dependency set that has a classpath module — its pure-ide-light (for legend-engine, legend-engine-pure-ide-light-http-server). That one module's runtime classpath already contains every dependency-repo jar below it, so it covers the whole stack: pure-lsp-classpath legend-engine builds from legend-engine's pure-ide-light module (covers legend-engine + legend-pure jars). A project layered in via PURE_DEV_EXTRA_PROJECTS_JSON with no classpath module of its own falls back the same way, to the highest dependency that has one (then you source-root the extra project for your edits).

Caching: per-project cache ~/.cache/pure-dev/classpath-<project>.txt + a .stamp (project git HEAD + module pom mtime). Reused until the checkout changes; recomputed on --force or staleness. -o (offline) is tried first, retried online if needed. dependency:build-classpath output is the os.pathsep-joined jar list --classpath-file expects.

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

Launching the LSP for a project (the whole point)

bash
# Work in legend-engine: DEFAULT already source-roots both legend-engine and legend-pure below it -
# no flag needed, edit anywhere in the stack:
pure-lsp-server $(pure-lsp-roots legend-engine) --classpath-file "$(pure-lsp-classpath legend-engine)" \
    --port 8991 --socket-port 9100 --jvm-arg=-Dlegend.test.server.* ...

# Narrow to JUST legend-engine (legend-pure resolves from the classpath jars instead):
pure-lsp-server $(pure-lsp-roots legend-engine --source legend-engine) \
    --classpath-file "$(pure-lsp-classpath legend-engine)" --port 8991 ...

--repo-root overrides which .pure is read from source; the --classpath-file still supplies the JVM's Java + every dependency-repo jar you are NOT source-rooting. (See references/lsp-devloop-internals.md for why both are needed.)

When to recompute

  • After git pull in the project or a dependency (the stamp catches most).
  • After mvn clean install that bumps a -SNAPSHOT version (jar paths change).
  • On a new machine (first call builds it; expect a Maven dependency-resolve pass).
  • If boot fails with "classpath file contains a missing entry" → --force.

Notes

  • First compute needs the classpath module resolvable (a prior mvn install of the project, which the dev setup already does). It resolves the dependency classpath; it does not build code.
  • Caches are per-machine and never committed. This replaces the deprecated shipped pure-ide-classpath.txt.

© 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-classpath of finos/legend-engine.

Open the folder on GitHubat commit 00108b7

Compare with similar skills

Pure Lsp Classpath 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 Classpath compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Pure Lsp Classpath this skillfinos/legend-engine112—~1.5kAutomated safety check: PassApache-2.0
Prompt Cachingdavila7/claude-code-templates32k6 repos~452Automated safety check: PassMIT
Turborepo Cachingwshobson/agents40k9 repos~2kAutomated safety check: NotesMIT
OmniRoute LLM Cachediegosouzapw/OmniRoute74k1 repos~529Automated safety check: PassMIT
Cachingzebbern/claude-code-guide4.7k—~1.5kAutomated safety check: PassMIT
Content-Hash File Cache Patternaffaan-m/ECC275k5 repos~1.4kAutomated safety check: PassMIT

Similar skills

  • Prompt Caching

    davila7/claude-code-templates

    Caching strategies for LLM prompts including Anthropic prompt caching, response caching, and CAG (Cache Augmented Generation) Use when: prompt caching, cache prompt, response cache, cag, cache…

    32k GitHub starsUsed in 6 repos~452 tokens
    Backend & APIsAuto-check passed

  • Turborepo Caching

    wshobson/agents

    Configures Turborepo pipelines and local or remote caching for monorepo builds, including Vercel remote cache, a self-hosted cache and cache-miss debugging.

    40k GitHub starsUsed in 9 repos~2k tokens
    DevelopmentAuto-check: notes

  • OmniRoute LLM Cache

    diegosouzapw/OmniRoute

    Documents OmniRoute's cache endpoints for reading cache statistics and clearing entries, statistics or the reasoning cache, with notes on TTL and similarity settings.

    74k GitHub starsUsed in 1 repo~529 tokens
    Backend & APIsAuto-check passed

  • Caching

    zebbern/claude-code-guide

    Caching strategies — invalidation, TTL guidelines, cache keys, cache layers, and when not to cache.

    4.7k GitHub stars~1.5k tokensUpdated yesterday
    Backend & APIsAuto-check passed

  • Content-Hash File Cache Pattern

    affaan-m/ECC

    Caches slow file processing results in Python keyed by a SHA-256 hash of the file content, so renames still hit the cache and edits invalidate it automatically.

    275k GitHub starsUsed in 5 repos~1.4k tokens
    DevelopmentAuto-check passed

  • 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 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.

    112 GitHub stars~1.2k tokensUpdated yesterday
    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.

    112 GitHub stars~1.8k tokensUpdated yesterday
    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…

    112 GitHub stars~1.6k tokensUpdated yesterday
    Auto-check passed

  • Pure Lsp Check

    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…

    112 GitHub stars~1.4k tokensUpdated yesterday
    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.

    112 GitHub stars~1.3k tokensUpdated yesterday
    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.

    112 GitHub stars~883 tokensUpdated yesterday
    Auto-check passed

Questions about Pure Lsp Classpath

What does Pure Lsp Classpath do?

Computes and caches the engine-scale Pure classpath (via Maven dependency:build-classpath) for any pure-bearing project registered in config/projects.json - legend-pure, legend-engine, or a project…. Pure Lsp Classpath is an agent skill from finos/legend-engine.json - legend-pure, legend-engine, or a project you've layered on top via PUREDEVEXTRAPROJECTSJSON - and resolves that project's dependency-ordered --repo-root set.

How do I install Pure Lsp Classpath in Claude Code?

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

How do I install Pure Lsp Classpath in Codex?

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

Can I use Pure Lsp Classpath 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-classpath -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-classpath, .gemini/skills/pure-lsp-classpath, .github/skills/pure-lsp-classpath and .opencode/skills/pure-lsp-classpath in your project.

What does Pure Lsp Classpath need to run?

Going by SKILL.md and its folder, Pure Lsp Classpath needs the command-line tools its instructions call (mvn and git).

Does Pure Lsp Classpath access the network?

SKILL.md contains no URLs. Its commands use git, which can reach the network depending on how they are called. This is read from the text; nothing was executed.

Is Pure Lsp Classpath 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 Classpath use?

Pure Lsp Classpath 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 Classpath use?

About 1.5k tokens (SKILL.md is roughly 6k 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 Classpath?

Skills that share tags, products or a category with Pure Lsp Classpath: Prompt Caching (davila7/claude-code-templates, 32k stars), Turborepo Caching (wshobson/agents, 40k stars), OmniRoute LLM Cache (diegosouzapw/OmniRoute, 74k stars) and Caching (zebbern/claude-code-guide, 4.7k stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Pure Lsp Classpath?

finos (a GitHub organization) maintains it in finos/legend-engine, which has 112 GitHub stars. The repository holds 15 skills in this directory. The repository was last updated on October 7, 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.