Hone Extensions

Built-in extensions that ship with every Hone IDE installation. This repository contains 11 extensions covering the most popular programming languages and developer tools — all implemented in TypeScript, compiled to native binaries by Perry, and loaded at runtime by Hone's extension host.

Extensions

Extension	Languages / Scope	LSP Server
typescript	TypeScript, JavaScript, TSX, JSX	`typescript-language-server`
python	Python	`pyright-langserver`
rust	Rust	`rust-analyzer`
go	Go, Go modules	`gopls`
cpp	C, C++, Objective-C	`clangd`
html-css	HTML, CSS, SCSS, Less	`vscode-html-language-server`, `vscode-css-language-server`
json	JSON, JSONC	`vscode-json-language-server`
markdown	Markdown	(built-in, no external server)
git	Git SCM integration	(uses Hone's built-in Git API)
docker	Dockerfile, docker-compose	`dockerfile-language-server-nodejs`
toml-yaml	TOML, YAML	`taplo`, `yaml-language-server`

What Each Extension Provides

IntelliSense — completions, hover documentation, go-to-definition, find references
Diagnostics — real-time errors and warnings from the language server
Formatting — document and range formatting via LSP
Code actions — quick fixes, refactors, and organize imports
Commands — language-specific commands in the command palette
Snippets — curated snippet libraries for fast coding
Syntax highlighting — language configuration for bracket matching, folding, and comments
Schema validation — JSON/TOML/YAML files validated against known schemas (SchemaStore)

Architecture

Each extension is a small, self-contained TypeScript package:

extensions/<name>/
├── hone-extension.json       # Manifest: identity, activation events, contributions
├── src/
│   └── index.ts              # activate() / deactivate() entry point
├── snippets/                 # Snippet JSON files
├── language-configuration.json  # Bracket pairs, comments, folding
└── tsconfig.json

Key Design Principles

Single import. Every extension imports only @honeide/api — no Node.js built-ins, no third-party npm packages, no cross-extension imports.

AOT compilation. Perry compiles each src/index.ts directly to a native dynamic library (.dylib / .so / .dll). No JavaScript runtime is bundled with Hone.

Independence. Extensions have no runtime dependencies on each other. Disabling any extension has zero effect on the others.

Lazy activation. Extensions activate only when needed — typically when a matching file is opened (onLanguage:) or a matching workspace file is detected (workspaceContains:).

Shared Utilities

shared/lsp-helpers.ts provides three utilities used by most extensions:

findExecutable(name) — searches PATH and common tool installation locations (~/.cargo/bin, ~/go/bin, ~/.local/bin, etc.)
registerLspServer(context, options) — registers an LSP server with automatic executable detection and a user-facing warning if the server is not installed
sendLspRequest<T>(client, method, params) — sends a typed custom LSP request

This file is compiled into each extension that uses it — it is not a shared library at runtime.

Extension Detail

TypeScript & JavaScript

Powered by typescript-language-server, which wraps the official tsserver. Provides completions, diagnostics, hover, go-to-definition, rename, code actions, and formatting across TypeScript, JavaScript, TSX, and JSX.

Commands: Organize Imports · Add Missing Imports · Rename File and Update Imports · Go to Source Definition · Restart Language Server

Configuration: typescript.format.semicolons, typescript.suggest.includeCompletionsForModuleExports, typescript.inlayHints.*, typescript.preferences.importModuleSpecifier

Python

Uses Pyright (pyright-langserver) for type-checked IntelliSense, diagnostics, and auto-import. Includes interpreter selection, virtual environment creation, and run-file/run-selection commands.

Commands: Run Python File · Run Selection in Terminal · Select Python Interpreter · Create Virtual Environment · Restart Language Server

Configuration: python.pythonPath, python.analysis.typeCheckingMode (off/basic/standard/strict), python.analysis.autoImportCompletions, python.formatting.provider

Rust

Backed by rust-analyzer. Exposes macro expansion, HIR inspection, docs.rs integration, parent module navigation, and matching brace navigation alongside standard LSP features.

Commands: Run · Check · Test · Expand Macro · View HIR · Open docs.rs · Locate Parent Module · Go to Matching Brace · Restart Server

Configuration: rust.checkOnSave.command (check/clippy), rust.cargo.features, rust.procMacro.enable, rust.inlayHints.*

Go

Uses gopls with full workspace support. Detects test functions at the cursor for go test -run <TestName>, handles file toggling between foo.go and foo_test.go, and forwards gopls code actions for generate tests, add struct tags, and fill struct.

Commands: Run Test · Run Test at Cursor · Go Mod Tidy · Generate Tests · Add Struct Tags · Fill Struct · Toggle Test File · Restart Server

Configuration: go.formatTool (gofmt/goimports/golines), go.lintTool, go.buildFlags, go.testFlags

C/C++

Configured for clangd with background indexing and clang-tidy integration. Automatically detects compile_commands.json in the workspace and passes --compile-commands-dir to clangd. Implements header/source switching via clangd's custom textDocument/switchSourceHeader LSP request.

Commands: Switch Header/Source (Alt+O) · Restart Server

Configuration: cpp.clangdPath, cpp.clangdArgs, cpp.compileCommands, cpp.fallbackFlags

HTML & CSS

Registers both vscode-html-language-server and vscode-css-language-server (from vscode-langservers-extracted). Includes a lightweight Emmet engine supporting tag expansion, class/ID shortcuts, child (>), sibling (+), and multiplication (*N) operators.

Commands: Emmet: Expand Abbreviation (Tab) · Emmet: Wrap with Abbreviation · Remove Tag · Update Tag · Pick Color

Configuration: html.autoClosingTags, html.autoRenameTag, html.format.wrapLineLength, css.validate, emmet.triggerExpansionOnTab

JSON

Uses vscode-json-language-server with a built-in schema catalog that covers package.json, tsconfig.json, .eslintrc.json, .prettierrc, hone-extension.json, perry.config.json, and *.schema.json out of the box. Custom schema associations can be added via json.schemas.

Commands: Sort JSON Keys · Format JSON · Minify JSON

Configuration: json.schemas (custom associations), json.format.enable, json.validate.enable, json.schemaDownload.enable

Markdown

No external LSP server — all features are implemented directly in TypeScript. Renders a live preview in a webview panel (debounced at 300ms) with GitHub Flavored Markdown support. The preview respects the editor's light/dark theme.

Commands: Open Preview · Open Preview to Side (Cmd+Shift+V) · Toggle Bold/Italic/Code/Strikethrough · Insert Link/Image/Table · Generate/Update Table of Contents

Configuration: markdown.preview.fontSize, markdown.preview.lineHeight, markdown.preview.scrollSync, markdown.preview.typographer

Git

The most complex built-in extension, split across four source files. Uses Hone's built-in hone.git.* API rather than an external LSP server.

src/blame.ts — inline blame annotations rendered as after-text decorations with configurable format string
src/statusbar.ts — status bar showing branch name, dirty indicator, and ahead/behind sync counts (auto-refreshes every 30s)
src/graph.ts — webview-based commit graph with branch labels, SVG lane drawing, and click-to-checkout
src/index.ts — all 18 SCM commands plus optional auto-fetch

Commands: Stage/Unstage File · Stage All · Commit · Commit All · Push · Pull · Fetch · Create/Switch/Delete Branch · View Log · View Graph · Toggle Blame · View File History · Diff with Previous · Stash · Pop Stash

Configuration: git.enabled, git.autofetch, git.blame.enabled, git.blame.format, git.confirmSync, git.enableSmartCommit

Docker

Registers dockerfile-language-server-nodejs for Dockerfile IntelliSense. Provides terminal-based commands for building images and managing containers, with configurable Docker executable path and compose command.

Commands: Build Image · Run Container · Compose Up · Compose Down · Restart Server

Configuration: docker.dockerPath, docker.composeCommand, docker.defaultBuildArgs

TOML & YAML

Registers taplo for TOML and yaml-language-server for YAML. Both servers provide schema-based validation. Built-in schema associations include Cargo.toml, pyproject.toml, docker-compose.yml, GitHub Actions workflows, GitLab CI, and more.

Commands: Restart TOML Server · Restart YAML Server

Configuration: toml.formatter.*, toml.schemas, yaml.schemas, yaml.format.*, yaml.validate, yaml.completion

Development

Prerequisites

Perry compiler (for building extensions)
Node.js 20+ and npm (for tests and scripts)
LSP server binaries installed on your system (for integration tests)

Setup

git clone https://github.com/HoneIDE/extensions
cd extensions
npm install

Testing

npm test              # Run all tests once
npm run test:watch    # Watch mode
npm run validate      # Validate all extension manifests
npm run typecheck     # TypeScript type-check (no emit)

Tests use Vitest with a mock @honeide/api — no IDE or LSP servers required to run the unit test suite.

Building

npm run build         # Compile all extensions via Perry → dist/
npm run bundle        # Bundle compiled extensions into IDE binary

Individual extension:

perry compile extensions/typescript/src/index.ts \
  --output-type dylib \
  --output dist/typescript/extension.dylib \
  --target current

Adding a New Extension

Create extensions/<name>/ with the standard structure
Write hone-extension.json following the manifest schema
Implement activate(context) and deactivate() in src/index.ts
Use registerLspServer from ../../shared/lsp-helpers for LSP setup
Add snippet JSON files and language-configuration.json as needed
Write tsconfig.json extending ../../tsconfig.base.json
Run npm run validate and npm test

External LSP Servers

Extensions configure and launch LSP servers but do not bundle them. Install the servers you need:

Extension	Server	Install
TypeScript	`typescript-language-server`	`npm i -g typescript-language-server typescript`
Python	`pyright-langserver`	`pip install pyright` or `npm i -g pyright`
Rust	`rust-analyzer`	`rustup component add rust-analyzer`
Go	`gopls`	`go install golang.org/x/tools/gopls@latest`
C/C++	`clangd`	OS package manager (e.g., `brew install llvm`)
HTML/CSS	`vscode-langservers-extracted`	`npm i -g vscode-langservers-extracted`
JSON	`vscode-langservers-extracted`	`npm i -g vscode-langservers-extracted`
Docker	`dockerfile-language-server-nodejs`	`npm i -g dockerfile-language-server-nodejs`
TOML	`taplo`	`cargo install taplo-cli`
YAML	`yaml-language-server`	`npm i -g yaml-language-server`

License

MIT — see LICENSE.

Part of the Hone IDE project.

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Repository files navigation

Hone Extensions

Extensions

What Each Extension Provides

Architecture

Key Design Principles

Shared Utilities

Extension Detail

TypeScript & JavaScript

Python

Rust

Go

C/C++

HTML & CSS

JSON

Markdown

Git

Docker

TOML & YAML

Development

Prerequisites

Setup

Testing

Building

Adding a New Extension

External LSP Servers

License

About

Uh oh!

Releases

Packages

Uh oh!

Contributors

Uh oh!

Languages

Name		Name	Last commit message	Last commit date
Latest commit History 1 Commit
extensions		extensions
scripts		scripts
shared		shared
tests		tests
.gitignore		.gitignore
CLAUDE.md		CLAUDE.md
LICENSE		LICENSE
PROJECT_PLAN.md		PROJECT_PLAN.md
README.md		README.md
package.json		package.json
perry.config.json		perry.config.json
tsconfig.base.json		tsconfig.base.json

License

HoneIDE/extensions

Folders and files

Latest commit

History

Repository files navigation

Hone Extensions

Extensions

What Each Extension Provides

Architecture

Key Design Principles

Shared Utilities

Extension Detail

TypeScript & JavaScript

Python

Rust

Go

C/C++

HTML & CSS

JSON

Markdown

Git

Docker

TOML & YAML

Development

Prerequisites

Setup

Testing

Building

Adding a New Extension

External LSP Servers

License

About

Topics

Resources

License

Uh oh!

Stars

Watchers

Forks

Releases

Packages 0

Uh oh!

Contributors

Uh oh!

Languages

Packages