@enjoys/context-engine

Comprehensive Monaco Editor language intelligence engine with 94 languages, 26 providers, and 464 CLI command files (447 unique) — completions, hover docs, definitions, code actions, code lens, document symbols, formatting, signature help, semantic tokens, inline completions, and more, all as pre-built JSON data with zero backend required.

Why Context Engine?

Traditional LSP (Language Server Protocol) setups require a backend server running a separate language server process for every language you want to support. Each language server needs its own binary installed — Go, Rust, Python, TypeScript, and so on. At scale, this makes the backend heavy, memory-hungry, and CPU-intensive. Supporting all languages can easily consume 1 GB+ of disk space and significant runtime resources just to keep those servers alive.

Context Engine takes a fundamentally different approach. Instead of running language servers on the backend, it ships pre-built, Monaco-compatible JSON data for 94 languages across 26 provider types — completions, hover docs, definitions, code actions, formatting rules, semantic tokens, and 464 CLI tool definitions — all in a single package. No language binaries to install. No background processes to manage. No backend required for intelligence.

Note: Context Engine does not provide path-based intelligence (file resolution, go-to-definition across files, etc.) the way a full LSP does. It focuses on language-aware completions, hover documentation, code actions, formatting, symbols, and terminal command autocomplete — the features that matter most in web-based terminal and editor experiences, without the infrastructure overhead.

Install

npm install @enjoys/context-engine

What's Inside

data/                        # 2,444 JSON files — 94 languages × 26 providers + 256 commands
├── codeActions/             # Quick-fix and refactoring actions
├── codeLens/                # Inline actionable annotations (references, tests)
├── color/                   # Color picker and decorator support
├── commands/                # 464 CLI tool definitions (git, docker, kubectl, ...)
├── completion/              # Monaco CompletionItem[] with snippets
├── declaration/             # Go-to-declaration data
├── definition/              # Definitions (signatures, descriptions, types)
├── documentHighlight/       # Symbol highlight on selection
├── documentRangeFormatting/ # Format-selection rules
├── documentSymbol/          # Outline / symbol tree patterns
├── foldingRange/            # Code folding regions
├── formatting/              # Full-document formatting rules
├── hover/                   # Hover documentation (IMarkdownString[])
├── implementation/          # Go-to-implementation data
├── inlayHints/              # Inline parameter/type hints
├── inlineCompletions/       # Ghost-text inline completions
├── linkedEditingRange/      # Linked editing (e.g. HTML tag pairs)
├── links/                   # Clickable document link patterns
├── onTypeFormatting/        # Format-as-you-type rules
├── rangeSemanticTokens/     # Range-scoped semantic tokens
├── references/              # Find-all-references patterns
├── rename/                  # Symbol rename validation and patterns
├── selectionRange/          # Smart selection expansion
├── semanticTokens/          # Full semantic tokenization
├── signatureHelp/           # Function signature tooltips
├── typeDefinition/          # Go-to-type-definition data
└── manifest.json            # Language registry with file mappings

Quick Start — Full Monaco Integration

This single example registers completions, hover, definitions, and command-line autocomplete for any language:

import * as monaco from 'monaco-editor';

// ── 1. Import language data (e.g., nginx) ──
import nginxCompletions from '@enjoys/context-engine/completion/nginx.json';
import nginxDefinitions from '@enjoys/context-engine/definition/nginx.json';
import nginxHovers from '@enjoys/context-engine/hover/nginx.json';

// ── 2. Import command data ──
import { getCommand, searchCommands, getSubcommands } from '@enjoys/context-engine';

// =============================================
// REGISTER COMPLETION PROVIDER
// =============================================
monaco.languages.registerCompletionItemProvider('nginx', {
  provideCompletionItems(model, position) {
    const word = model.getWordUntilPosition(position);
    const range = {
      startLineNumber: position.lineNumber,
      endLineNumber: position.lineNumber,
      startColumn: word.startColumn,
      endColumn: word.endColumn,
    };

    // Map data to Monaco CompletionItems
    const suggestions = nginxCompletions.completions.map((item) => ({
      label: item.label,
      kind: item.kind,                              // e.g. 15 = Snippet
      detail: item.detail,
      documentation: item.documentation?.value
        ? { value: item.documentation.value, isTrusted: true }
        : undefined,
      insertText: item.insertText,
      insertTextRules: item.insertTextRules,         // 4 = InsertAsSnippet
      sortText: item.sortText,
      range,
    }));

    return { suggestions };
  },
});

// =============================================
// REGISTER HOVER PROVIDER
// =============================================
monaco.languages.registerHoverProvider('nginx', {
  provideHover(model, position) {
    const word = model.getWordAtPosition(position);
    if (!word) return null;

    const key = word.word.toLowerCase();
    const hover = nginxHovers.hovers[key];
    if (!hover) return null;

    return {
      range: new monaco.Range(
        position.lineNumber,
        word.startColumn,
        position.lineNumber,
        word.endColumn
      ),
      contents: hover.contents.map((c) => ({
        value: c.value,
        isTrusted: true,
        supportThemeIcons: true,
      })),
    };
  },
});

// =============================================
// REGISTER DEFINITION PROVIDER (Peek Definition)
// =============================================
monaco.languages.registerDefinitionProvider('nginx', {
  provideDefinition(model, position) {
    const word = model.getWordAtPosition(position);
    if (!word) return null;

    const key = word.word.toLowerCase();
    const def = nginxDefinitions.definitions[key];
    if (!def) return null;

    // Search the document for the first occurrence of this keyword
    const text = model.getValue();
    const lines = text.split('\n');
    for (let i = 0; i < lines.length; i++) {
      const col = lines[i].indexOf(word.word);
      if (col !== -1) {
        return {
          uri: model.uri,
          range: new monaco.Range(i + 1, col + 1, i + 1, col + 1 + word.word.length),
        };
      }
    }
    return null;
  },
});

// =============================================
// SHOW DEFINITION INFO IN A CUSTOM WIDGET
// =============================================
// You can use definitions data to build a sidebar, tooltip, or panel:
function getDefinitionInfo(keyword) {
  const def = nginxDefinitions.definitions[keyword];
  if (!def) return null;
  return {
    signature: def.signature,     // e.g. "proxy_pass URL"
    description: def.description, // e.g. "Forwards requests to backend..."
    type: def.type,               // e.g. "directive"
    module: def.module,           // e.g. "ngx_http_proxy_module"
  };
}

// Example:
// getDefinitionInfo('proxy_pass')
// → { signature: "proxy_pass URL", description: "Sets the protocol and address...", type: "directive", module: "ngx_http_proxy_module" }

Register Multiple Languages at Once

import manifest from '@enjoys/context-engine/data/manifest.json';

// Dynamically register all 94 languages
for (const lang of manifest.languages) {
  const completionData = await import(`@enjoys/context-engine/${lang.files.completion}`);
  const hoverData = await import(`@enjoys/context-engine/${lang.files.hover}`);
  const defData = await import(`@enjoys/context-engine/${lang.files.definition}`);

  monaco.languages.registerCompletionItemProvider(lang.id, {
    provideCompletionItems(model, position) {
      const word = model.getWordUntilPosition(position);
      const range = {
        startLineNumber: position.lineNumber,
        endLineNumber: position.lineNumber,
        startColumn: word.startColumn,
        endColumn: word.endColumn,
      };
      return {
        suggestions: completionData.completions.map((item) => ({
          label: item.label,
          kind: item.kind,
          detail: item.detail,
          documentation: item.documentation?.value
            ? { value: item.documentation.value, isTrusted: true }
            : undefined,
          insertText: item.insertText,
          insertTextRules: item.insertTextRules,
          sortText: item.sortText,
          range,
        })),
      };
    },
  });

  monaco.languages.registerHoverProvider(lang.id, {
    provideHover(model, position) {
      const word = model.getWordAtPosition(position);
      if (!word) return null;
      const hover = hoverData.hovers[word.word.toLowerCase()];
      if (!hover) return null;
      return {
        range: new monaco.Range(position.lineNumber, word.startColumn, position.lineNumber, word.endColumn),
        contents: hover.contents.map((c) => ({ value: c.value, isTrusted: true })),
      };
    },
  });
}

Register Additional Providers

import codeActionsData from '@enjoys/context-engine/data/codeActions/typescript.json';
import codeLensData from '@enjoys/context-engine/data/codeLens/typescript.json';
import symbolData from '@enjoys/context-engine/data/documentSymbol/typescript.json';
import highlightData from '@enjoys/context-engine/data/documentHighlight/typescript.json';
import signatureData from '@enjoys/context-engine/data/signatureHelp/typescript.json';

// ── Code Actions (Quick Fix, Refactor) ──
monaco.languages.registerCodeActionProvider('typescript', {
  provideCodeActions(model, range, context) {
    return {
      actions: codeActionsData.codeActions.map((a) => ({
        title: a.title,
        kind: a.kind,
        diagnostics: [],
        isPreferred: a.isPreferred || false,
      })),
      dispose() {},
    };
  },
});

// ── Code Lens (References, Run Test) ──
monaco.languages.registerCodeLensProvider('typescript', {
  provideCodeLenses(model) {
    const lenses = [];
    const text = model.getValue();
    for (const pattern of codeLensData.codeLensPatterns) {
      const regex = new RegExp(pattern.pattern, 'gm');
      let match;
      while ((match = regex.exec(text))) {
        const line = model.getPositionAt(match.index).lineNumber;
        lenses.push({
          range: new monaco.Range(line, 1, line, 1),
          command: { id: pattern.commandId, title: pattern.title },
        });
      }
    }
    return { lenses, dispose() {} };
  },
});

// ── Document Symbols (Outline) ──
monaco.languages.registerDocumentSymbolProvider('typescript', {
  provideDocumentSymbols(model) {
    const symbols = [];
    const text = model.getValue();
    for (const sp of symbolData.symbolPatterns) {
      const regex = new RegExp(sp.pattern, 'gm');
      let match;
      while ((match = regex.exec(text))) {
        const pos = model.getPositionAt(match.index);
        const name = match[sp.captureGroup || 1] || match[0];
        symbols.push({
          name,
          kind: sp.kind,
          range: new monaco.Range(pos.lineNumber, 1, pos.lineNumber, model.getLineMaxColumn(pos.lineNumber)),
          selectionRange: new monaco.Range(pos.lineNumber, pos.column, pos.lineNumber, pos.column + name.length),
        });
      }
    }
    return symbols;
  },
});

// ── Signature Help ──
monaco.languages.registerSignatureHelpProvider('typescript', {
  signatureHelpTriggerCharacters: signatureData.triggerCharacters || ['(', ','],
  provideSignatureHelp(model, position) {
    const word = model.getWordAtPosition(position);
    if (!word || !signatureData.signatures) return null;
    const sig = signatureData.signatures[word.word];
    if (!sig) return null;
    return {
      value: {
        signatures: [{
          label: sig.label,
          parameters: (sig.params || []).map((p) => ({ label: p.label, documentation: p.documentation })),
          documentation: sig.documentation,
        }],
        activeSignature: 0,
        activeParameter: 0,
      },
      dispose() {},
    };
  },
});

Terminal Autocomplete — Command Engine API

Use the command engine to build intelligent terminal autocomplete (like Fig or Warp):

import {
  getCommand,
  getAllCommands,
  listCommandNames,
  searchCommands,
  getCommandsByCategory,
  getCommandsByPlatform,
  getCategories,
  getContextEngine,
  getSubcommands,
  getGlobalOptions,
  getExamples,
  count,
} from '@enjoys/context-engine';

getCommand(name)

Get a single command definition by name.

const git = getCommand('git');
console.log(git.subcommands.map((s) => s.name));
// ['init', 'clone', 'add', 'commit', 'push', ...]

searchCommands(query)

Search commands by name, description, or category (case-insensitive).

searchCommands('docker');
// [{ name: 'docker', ... }, { name: 'docker-compose', ... }]

searchCommands('database');
// [{ name: 'psql', ... }, { name: 'mysql', ... }, { name: 'mongosh', ... }]

getSubcommands(name)

getSubcommands('systemctl');
// [{ name: 'start', description: 'Start (activate) one or more units', args: [...], examples: [...] },
//  { name: 'stop', ... }, { name: 'restart', ... }, { name: 'status', ... },
//  { name: 'enable', options: [{ name: '--now' }], ... }, ... ]  (35 subcommands)

getGlobalOptions(name)

getGlobalOptions('journalctl');
// [{ name: '-u', description: 'Show logs for a specific unit' },
//  { name: '-f', description: 'Follow — show new log entries' },
//  { name: '-n', description: 'Number of lines to show' }, ...]  (32 options)

getExamples(name)

getExamples('nginx');
// ['nginx -t', 'nginx -s reload', 'sudo nginx -t && sudo nginx -s reload', ...]

getContextEngine(name)

Get runtime context detectors for a command — shell commands that gather live context.

const ctx = getContextEngine('docker');
// {
//   detectors: [
//     { name: 'containers', command: 'docker ps ...', parser: 'lines', cacheFor: 10 },
//     { name: 'images', command: 'docker images ...', parser: 'lines', cacheFor: 30 },
//     ...
//   ]
// }

getCommandsByCategory(category) / getCommandsByPlatform(platform)

getCommandsByCategory('database');
// [psql, mysql, mongosh, sqlite3, redis-cli, cockroach, influx, clickhouse-client, ...]

getCommandsByPlatform('windows');
// [choco, winget, ...]

getCategories()

getCategories();
// ['Build Tools', 'Cloud CLIs', 'Container', 'Database', 'DevOps', ...]

count()

count(); // 395

resolveCommandPath(name) / dataDir

resolveCommandPath('git');
// '/path/to/node_modules/@enjoys/context-engine/data/commands/git.json'

clearCache()

Clear the in-memory cache (useful in tests).

Full Terminal Autocomplete Example

Build a terminal autocomplete that suggests subcommands, options, and uses context detectors:

import { getCommand, getContextEngine, searchCommands } from '@enjoys/context-engine';
import { exec } from 'child_process';
import { promisify } from 'util';

const execAsync = promisify(exec);

// ── Run a context detector and cache results ──
const cache = new Map();

async function runDetector(detector) {
  const cached = cache.get(detector.name);
  if (cached && Date.now() - cached.time < (detector.cacheFor || 30) * 1000) {
    return cached.data;
  }

  try {
    const { stdout } = await execAsync(detector.command, { timeout: 5000 });
    let data;
    switch (detector.parser) {
      case 'lines': data = stdout.trim().split('\n').filter(Boolean); break;
      case 'json':  data = JSON.parse(stdout); break;
      default:      data = stdout.trim(); break;
    }
    cache.set(detector.name, { data, time: Date.now() });
    return data;
  } catch {
    return null;
  }
}

// ── Autocomplete function ──
async function getCompletions(inputLine) {
  const parts = inputLine.trim().split(/\s+/);
  const cmdName = parts[0];
  const cmd = getCommand(cmdName);
  if (!cmd) {
    // Suggest matching command names
    return searchCommands(cmdName).map((c) => ({
      label: c.name,
      detail: c.description,
    }));
  }

  // User typed "systemctl " — suggest subcommands
  if (parts.length === 1 || (parts.length === 2 && !parts[1].startsWith('-'))) {
    const items = cmd.subcommands.map((s) => ({
      label: s.name,
      detail: s.description,
    }));

    // Also add context detectors (e.g., running services, failed units)
    const ctx = getContextEngine(cmdName);
    if (ctx) {
      for (const detector of ctx.detectors) {
        const data = await runDetector(detector);
        if (Array.isArray(data)) {
          items.push(...data.map((d) => ({
            label: d,
            detail: `[${detector.name}]`,
          })));
        }
      }
    }
    return items;
  }

  // User typed "systemctl start " — suggest from detectors
  const subName = parts[1];
  const sub = cmd.subcommands.find((s) => s.name === subName);
  if (sub?.options) {
    return sub.options.map((o) => ({
      label: o.name,
      detail: o.description,
    }));
  }

  return cmd.globalOptions.map((o) => ({
    label: o.name,
    detail: o.description,
  }));
}

// Usage:
// await getCompletions('systemctl ')      → 35 subcommands + live context
// await getCompletions('systemctl start') → running/enabled services
// await getCompletions('docker ')         → subcommands + running containers
// await getCompletions('git ')            → subcommands + branches

Direct JSON Import

Access raw JSON files directly:

// Command data
const git = require('@enjoys/context-engine/commands/git.json');

// Language data
const nginxCompletion = require('@enjoys/context-engine/completion/nginx.json');
const nginxDefinition = require('@enjoys/context-engine/definition/nginx.json');
const nginxHover = require('@enjoys/context-engine/hover/nginx.json');

// Manifest (all languages)
const manifest = require('@enjoys/context-engine/data/manifest.json');

Data Formats

Completion Item (data/completion/*.json)

{
  "language": "nginx",
  "completions": [
    {
      "label": "server block",
      "kind": 15,
      "detail": "Server block",
      "documentation": { "value": "Defines a virtual server." },
      "insertText": "server {\n    listen ${1:80};\n    server_name ${2:example.com};\n    ...\n}",
      "insertTextRules": 4,
      "sortText": "00_server"
    }
  ]
}

kind values (CompletionItemKind): 0 = Method, 1 = Function, 2 = Constructor, 3 = Field, 4 = Variable, 5 = Class, 6 = Struct, 7 = Interface, 8 = Module, 9 = Property, 10 = Event, 11 = Operator, 12 = Unit, 13 = Value, 14 = Constant, 15 = Enum, 16 = EnumMember, 17 = Keyword, 18 = Text, 19 = Color, 20 = File, 21 = Reference, 22 = Customcolor, 23 = Folder, 24 = TypeParameter, 25 = User, 26 = Issue, 27 = Tool, 28 = Snippet
insertTextRules: 0 = None, 1 = KeepWhitespace, 4 = InsertAsSnippet (supports ${1:placeholder} tab stops)

Definition Item (data/definition/*.json)

{
  "language": "nginx",
  "definitions": {
    "proxy_pass": {
      "signature": "proxy_pass URL",
      "description": "Sets the protocol and address of a proxied server.",
      "type": "directive",
      "module": "ngx_http_proxy_module"
    }
  }
}

Hover Item (data/hover/*.json)

{
  "language": "nginx",
  "hovers": {
    "server": {
      "contents": [
        {
          "value": "```nginx\nserver {\n    listen 80;\n    server_name example.com;\n    ...\n}\n```\n**server** block defines a virtual host."
        }
      ]
    }
  }
}

Command Definition (data/commands/*.json)

{
  "name": "systemctl",
  "description": "Control the systemd system and service manager",
  "category": "system",
  "platforms": ["linux"],
  "shells": ["bash", "zsh", "fish"],
  "subcommands": [
    {
      "name": "start",
      "description": "Start one or more units",
      "args": [{ "name": "<unit>", "type": "string", "required": true }],
      "examples": ["systemctl start nginx"]
    }
  ],
  "globalOptions": [
    { "name": "--no-pager", "description": "Do not pipe output into pager" }
  ],
  "examples": ["systemctl start nginx", "systemctl status nginx -l"],
  "relatedCommands": ["journalctl", "systemd-analyze"],
  "contextEngine": {
    "detectors": [
      {
        "name": "failed_units",
        "command": "systemctl --failed --no-legend --plain 2>/dev/null | head -20",
        "parser": "lines",
        "cacheFor": 10,
        "requiresCmd": "systemctl"
      }
    ]
  }
}

Supported Languages (94)

Each language has up to 26 provider files — completions, hover, definitions, code actions, formatting, symbols, and more.

| Category | Languages | |----------|-----------| | Web | JavaScript, TypeScript, HTML, CSS, Less, SCSS, React, Angular, Next.js, Nest.js, Tailwind CSS | | UI / Templating | Liquid, Twig, FreeMarker2, Razor, shadcn, MDX | | Systems | C, C++, Rust, Go, Swift, Objective-C | | JVM | Java, Kotlin, Scala, Clojure | | .NET | C#, VB, Q# | | Scripting | Python, Ruby, Perl, Lua, PHP, Elixir, CoffeeScript, R | | Shell | Shell/Bash, PowerShell, AWK, Azure CLI | | Functional | Scheme, Julia, CameLIGO, PascaLIGO, Dart | | Database / Query | SQL, MySQL, PostgreSQL, Redshift, Redis, redis-cli, Cypher, SPARQL | | Config / Infrastructure | Dockerfile, Docker Compose, YAML, TOML, JSON, XML, INI, Dotenv, SSH Config, HCL, Makefile, Nginx, systemd, Caddy | | Docs / Markup | Markdown, MDX, reStructuredText | | Data / BI | MSDAX, Power Query, GraphQL | | Blockchain | Solidity, Lexon, Bicep | | Hardware / Low-Level | MIPS, SystemVerilog, WGSL, Structured Text | | Enterprise / Niche | ABAP, Apex, ECL, Flow9, M3, Pascal, PLA, Postiats, SB | | Other | Crontab, Protobuf, Doctest |

Covered Commands (464 files, 447 unique)

| Category | Tools | |----------|-------| | Cloud CLIs & APIs | aws, az, gcloud, doctl, linode-cli, vercel, netlify, firebase, supabase, railway, render, flyctl, cloudflare, aws-vault, auth0, stripe, twilio, sfdx, cdk, sam, serverless, eksctl, wrangler, func, heroku, oci, ibmcloud, aliyun, openstack, civo, scw, vultr, hcloud, upcloud, aws-copilot, amplify, eb, s3cmd, chamber, gsutil, bq, az-devops, ecs-cli, lightsail, rclone, mc | | Containers & Orchestration | docker, docker-compose, dockerfile, kubectl, helm, minikube, k9s, podman, buildah, skopeo, kind, kustomize, argocd, istioctl, crane, ko, rancher, linkerd, flux, tkn, crossplane, argo, velero, kubectx, kubens, stern, k3s, k3d, helmfile, kubeconform, popeye, kube-score, skaffold, tilt, telepresence, devspace, okteto, garden, cilium, calicoctl, cmctl, kn, kamel | | Version Control & Git Workflow | git, gh, glab, svn, hg, git-lfs, husky, commitlint, semantic-release, conventional-commits, pre-commit | | Node.js Ecosystem | node, npm, npx, yarn, pnpm, bun, deno, eslint, prettier, tsc, turbo, nx, vite, next, nest | | JS Build Tools | webpack, esbuild, rollup, swc, babel, storybook, lerna, changeset, concurrently | | Frameworks | angular, react, nextjs, nestjs, nuxt, vue, shadcn, tailwindcss, rails, artisan | | Static Site Generators | hugo, jekyll, gatsby, astro, eleventy, hexo, svelte, remix | | Python Ecosystem | python, pip, pipx, poetry, pipenv, conda, pytest, uvicorn, gunicorn, django-admin, flask, locust | | Rust & Go | rust, cargo, rustup, wasm-pack, rustc, go, gofmt, golangci-lint, air | | Java/JVM | java, javac, gradle, mvn, kotlin, scala, clojure, sdkman | | Haskell | ghc, cabal, stack | | Elixir & Erlang | mix, rebar3, erlang | | OCaml | ocaml, opam | | Other Languages | dotnet, zig, nim, crystal, swiftc, c (gcc/clang), cpp (g++), javascript, typescript, csharp, objective-c, swift, perl, lua, r, scheme, julia, pascal, tcl, vb, qsharp, coffee | | PHP | php, composer, artisan, symfony, wp | | Ruby | ruby, gem, bundle, rails, rake, rspec, rbenv, pod, fastlane | | Mobile | adb, dart, flutter, expo, react-native, xcodebuild, fastlane | | Database | sql, psql, pgsql, pg_dump, pg_restore, mysql, mongosh, redis, redis-cli, sqlite3, cockroach, influx, clickhouse-client, cypher, redshift | | Database ORMs/Migrations | prisma, drizzle-kit, typeorm, sequelize, alembic, dbmate, flyway, liquibase, atlas | | DevOps & Infrastructure | terraform, terragrunt, pulumi, packer, vault, consul, nomad, ansible, vagrant | | DevOps Quality | shellcheck, hadolint, act, semgrep, checkov, tflint | | Web Servers | nginx, caddy, httpd, apachectl | | Networking | curl, wget, rsync, ssh, ssh-keygen, ip, ss, ping, dig, nslookup, traceroute, tracert, netstat, ifconfig, route, hostname, nc, socat, nmap, tcpdump, wireshark, cloudflared | | Security | openssl, certbot, snyk, trivy, sonar-scanner, gpg, age, sops, cosign, syft, grype, doppler, infisical | | System & Monitoring | systemctl, journalctl, systemd-analyze, systemd, pm2, tmux, screen, htop, btop, top, ps, linux, crontab, kill, killall, df, du, free, lsof, mount, umount, env, watch, dmesg, strace, nohup, at, cron, hostname, prometheus, grafana-cli | | Linux Coreutils | ls, cp, mv, rm, cat, find, tar, chmod, chown, cd, sudo, scp, unzip, zip, ufw, iptables, nft, mkdir, touch, echo, head, tail, wc, sort, uniq, cut, diff, patch, ln, xargs, tee, which, whoami, id | | Build Tools | make, makefile, cmake, bazel, just, gradle | | Version Managers | nvm, fnm, pyenv, rbenv, asdf, volta, sdkman, mise | | HTTP/API Testing | httpie, ab, wrk, hey, vegeta, grpcurl, postman | | Data Processing | csvkit, miller, xsv, q, sqlite-utils | | Media & Documents | ffmpeg, imagemagick, pandoc, latex, ghostscript | | Package Managers | apt, apt-get, yum, dnf, pacman, brew, choco, winget, pipx, composer, bundle | | Testing | jest, vitest, mocha, playwright, cypress, k6, locust | | Text Processing & Utilities | grep, sed, awk, jq, yq, bat, cat, fd, fzf, rg, parallel, entr, inotifywait | | Text Editors | nvim, vim | | Config & Data Formats | json, xml, yaml, toml, ini, hcl, dotenv, markdown, mdx, restructuredtext, protobuf, graphql, scss, less, css, html, liquid, twig, razor, freemarker2 | | Niche & Specialized | abap, bicep, azcli, cameligo, pascaligo, ecl, flow9, lexon, m3, mips, msdax, pla, postiats, powerquery, sb, sol, sparql, st, systemverilog, wgsl, doctest |

Context Engine

Each command can include a contextEngine with runtime detectors — shell commands that gather live context (running containers, git branches, installed packages, etc.) for intelligent autocomplete:

const { getContextEngine } = require('@enjoys/context-engine');

const ctx = getContextEngine('systemctl');
// {
//   detectors: [
//     { name: 'failed_units', command: 'systemctl --failed ...', parser: 'lines', cacheFor: 10 },
//     { name: 'running_services', command: 'systemctl list-units ...', parser: 'text', cacheFor: 15 },
//     { name: 'active_timers', command: 'systemctl list-timers ...', parser: 'lines', cacheFor: 30 },
//     ...
//   ]
// }

Parser types: text | lines | json | csv | keyvalue | regex | table

All 26 Monaco Provider Types — Shipped

Every provider below is fully implemented for all 94 languages with spec-compliant JSON data:

| Provider | Registration Method | Data Key | |----------|-------------------|----------| | Completion | registerCompletionItemProvider | completions[] | | Hover | registerHoverProvider | hovers{} | | Definition | registerDefinitionProvider | definitions{} | | Code Actions | registerCodeActionProvider | codeActions[] | | Code Lens | registerCodeLensProvider | codeLensPatterns[] | | Color | registerColorProvider | colorPatterns[] | | Declaration | registerDeclarationProvider | declarations{} | | Document Highlight | registerDocumentHighlightProvider | highlights{} | | Document Symbol | registerDocumentSymbolProvider | symbolPatterns[] | | Document Range Formatting | registerDocumentRangeFormattingEditProvider | formatting{} | | Folding Range | registerFoldingRangeProvider | foldingRules[] | | Formatting | registerDocumentFormattingEditProvider | formatting{} | | Implementation | registerImplementationProvider | implementations{} | | Inlay Hints | registerInlayHintsProvider | inlayHints[] | | Inline Completions | registerInlineCompletionsProvider | inlineCompletions[] | | Linked Editing Range | registerLinkedEditingRangeProvider | linkedEditingPatterns[] | | Links | registerLinkProvider | linkPatterns[] | | On-Type Formatting | registerOnTypeFormattingEditProvider | formatting{} | | Range Semantic Tokens | registerDocumentRangeSemanticTokensProvider | tokenTypes[] | | References | registerReferenceProvider | referencePatterns[] | | Rename | registerRenameProvider | renameValidation{} | | Selection Range | registerSelectionRangeProvider | selectionRanges{} | | Semantic Tokens | registerDocumentSemanticTokensProvider | tokenTypes[] | | Signature Help | registerSignatureHelpProvider | signatures{} | | Type Definition | registerTypeDefinitionProvider | typeDefinitions{} | | Commands (CLI) | Custom API | subcommands[], globalOptions[] |

License

MIT © Enjoys Inc