@treelsp/cli 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 treelsp contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/index.js

@@ -0,0 +1,472 @@
+#!/usr/bin/env node
+import { Command } from "commander";
+import prompts from "prompts";
+import ora from "ora";
+import pc from "picocolors";
+import { mkdir, writeFile } from "node:fs/promises";
+import { resolve } from "node:path";
+import { copyFileSync, existsSync, readdirSync, renameSync, rmSync, writeFileSync } from "node:fs";
+import { pathToFileURL } from "node:url";
+import { generateAstTypes, generateGrammar, generateHighlights, generateLocals, generateManifest } from "treelsp/codegen";
+import { execSync } from "node:child_process";
+import { build } from "esbuild";
+import chokidar from "chokidar";
+
+//#region src/commands/init.ts
+async function init() {
+	console.log(pc.bold("treelsp init\n"));
+	const answers = await prompts([{
+		type: "text",
+		name: "name",
+		message: "Language name:",
+		initial: "my-lang",
+		validate: (value) => value.length > 0 || "Name is required"
+	}, {
+		type: "text",
+		name: "extension",
+		message: "File extension:",
+		initial: ".mylang",
+		validate: (value) => {
+			if (!value.startsWith(".")) return "Extension must start with a dot";
+			if (value.length < 2) return "Extension is too short";
+			return true;
+		}
+	}]);
+	if (!answers.name || !answers.extension) {
+		console.log(pc.dim("\nCancelled"));
+		process.exit(0);
+	}
+	const { name, extension } = answers;
+	const spinner = ora("Creating project structure...").start();
+	try {
+		const projectDir = resolve(process.cwd(), name);
+		if (existsSync(projectDir)) {
+			spinner.fail(`Directory "${name}" already exists`);
+			console.log(pc.dim("\nChoose a different name or remove the existing directory"));
+			process.exit(1);
+		}
+		await mkdir(projectDir);
+		const packageJson = {
+			name,
+			version: "0.1.0",
+			type: "module",
+			dependencies: { treelsp: "^0.0.1" },
+			devDependencies: {
+				"@treelsp/cli": "^0.0.1",
+				typescript: "^5.7.3"
+			},
+			scripts: {
+				generate: "treelsp generate",
+				build: "treelsp build",
+				watch: "treelsp watch"
+			}
+		};
+		await writeFile(resolve(projectDir, "package.json"), JSON.stringify(packageJson, null, 2) + "\n", "utf-8");
+		const tsconfig = {
+			extends: "treelsp/tsconfig.base.json",
+			compilerOptions: { outDir: "./dist" },
+			include: ["grammar.ts"]
+		};
+		await writeFile(resolve(projectDir, "tsconfig.json"), JSON.stringify(tsconfig, null, 2) + "\n", "utf-8");
+		const capitalizedName = name.split("-").map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join("");
+		const grammarTemplate = `/**
+ * ${capitalizedName} - Language definition for treelsp
+ */
+
+import { defineLanguage } from 'treelsp';
+
+export default defineLanguage({
+  name: '${capitalizedName}',
+  fileExtensions: ['${extension}'],
+  entry: 'program',
+  word: 'identifier',
+
+  grammar: {
+    // Program is a sequence of statements
+    program: r => r.repeat(r.rule('statement')),
+
+    // Define your language's statement types
+    statement: r => r.choice(
+      r.rule('variable_decl'),
+      r.rule('expr_statement'),
+    ),
+
+    // Variable declaration: let name = value;
+    variable_decl: r => r.seq(
+      'let',
+      r.field('name', r.rule('identifier')),
+      '=',
+      r.field('value', r.rule('expression')),
+      ';',
+    ),
+
+    // Expression statement: expr;
+    expr_statement: r => r.seq(
+      r.field('expr', r.rule('expression')),
+      ';',
+    ),
+
+    // Define your language's expressions
+    expression: r => r.choice(
+      r.rule('identifier'),
+      r.rule('number'),
+    ),
+
+    // Tokens
+    identifier: r => r.token(/[a-zA-Z_][a-zA-Z0-9_]*/),
+    number: r => r.token(/[0-9]+/),
+  },
+
+  semantic: {
+    // Program creates global scope
+    program: { scope: 'global' },
+
+    // Variable declarations introduce names
+    variable_decl: {
+      declares: {
+        field: 'name',
+        scope: 'enclosing',
+      },
+    },
+
+    // Identifiers in expressions are references
+    identifier: {
+      references: {
+        field: 'name',
+        to: 'variable_decl',
+        onUnresolved: 'error',
+      },
+    },
+  },
+
+  validation: {
+    // Add your custom validation rules here
+  },
+
+  lsp: {
+    // Keyword completions
+    $keywords: {
+      'let': { detail: 'Declare a variable' },
+    },
+
+    // Hover for variables
+    variable_decl: {
+      completionKind: 'Variable',
+      symbol: {
+        kind: 'Variable',
+        label: n => n.field('name').text,
+      },
+      hover(node, ctx) {
+        const name = node.field('name').text;
+        return \`**let** \\\`\${name}\\\`\`;
+      },
+    },
+  },
+});
+`;
+		await writeFile(resolve(projectDir, "grammar.ts"), grammarTemplate, "utf-8");
+		const gitignore = `node_modules
+dist
+generated/
+*.wasm
+*.log
+*.tsbuildinfo
+.DS_Store
+`;
+		await writeFile(resolve(projectDir, ".gitignore"), gitignore, "utf-8");
+		const readme = `# ${capitalizedName}
+
+A language definition for treelsp.
+
+## Getting Started
+
+Install dependencies:
+
+\`\`\`bash
+npm install
+# or: pnpm install
+\`\`\`
+
+Generate grammar and build parser:
+
+\`\`\`bash
+npm run generate  # Generates grammar.js, ast.ts, server.ts
+npm run build     # Compiles to WASM
+\`\`\`
+
+Development workflow:
+
+\`\`\`bash
+npm run watch     # Auto-rebuild on changes
+\`\`\`
+
+## Project Structure
+
+- \`grammar.ts\` - Language definition (grammar, semantic, validation, LSP)
+- \`generated/\` - Generated files (grammar.js, WASM, types)
+- \`package.json\` - Project dependencies
+
+## Documentation
+
+- [treelsp Documentation](https://github.com/yourusername/treelsp)
+- [Tree-sitter](https://tree-sitter.github.io/tree-sitter/)
+
+## License
+
+MIT
+`;
+		await writeFile(resolve(projectDir, "README.md"), readme, "utf-8");
+		spinner.succeed("Project created!");
+		console.log(pc.dim("\nNext steps:"));
+		console.log(pc.dim(`  cd ${name}`));
+		console.log(pc.dim("  npm install"));
+		console.log(pc.dim("  Edit grammar.ts to define your language"));
+		console.log(pc.dim("  npm run generate"));
+		console.log(pc.dim("  npm run build"));
+	} catch (error) {
+		spinner.fail("Failed to create project");
+		if (error instanceof Error) console.error(pc.red(`\n${error.message}`));
+		process.exit(1);
+	}
+}
+
+//#endregion
+//#region src/commands/generate.ts
+async function generate(options) {
+	const spinner = ora("Loading grammar.ts...").start();
+	try {
+		const grammarPath = resolve(process.cwd(), "grammar.ts");
+		if (!existsSync(grammarPath)) {
+			spinner.fail("Could not find grammar.ts in current directory");
+			console.log(pc.dim("\nRun \"treelsp init\" to create a new language project"));
+			process.exit(1);
+		}
+		const grammarUrl = pathToFileURL(grammarPath).href;
+		const module = await import(grammarUrl);
+		const definition = module.default;
+		if (!definition || !definition.name || !definition.grammar) {
+			spinner.fail("Invalid language definition");
+			console.log(pc.dim("\nEnsure grammar.ts exports a valid language definition using defineLanguage()"));
+			process.exit(1);
+		}
+		spinner.text = `Generating code for ${definition.name}...`;
+		const grammarJs = generateGrammar(definition);
+		const astTypes = generateAstTypes(definition);
+		const manifest = generateManifest(definition);
+		const highlightsSCM = generateHighlights(definition);
+		const localsSCM = generateLocals(definition);
+		const genDir = resolve(process.cwd(), "generated");
+		const queriesDir = resolve(genDir, "queries");
+		await mkdir(queriesDir, { recursive: true });
+		await Promise.all([
+			writeFile(resolve(genDir, "grammar.js"), grammarJs, "utf-8"),
+			writeFile(resolve(genDir, "ast.ts"), astTypes, "utf-8"),
+			writeFile(resolve(genDir, "treelsp.json"), manifest, "utf-8"),
+			writeFile(resolve(queriesDir, "highlights.scm"), highlightsSCM, "utf-8"),
+			writeFile(resolve(queriesDir, "locals.scm"), localsSCM, "utf-8")
+		]);
+		spinner.succeed("Generated grammar.js, ast.ts, treelsp.json, queries/highlights.scm, queries/locals.scm");
+		if (!options.watch) console.log(pc.dim("\nNext step: Run \"treelsp build\" to compile grammar to WASM"));
+	} catch (error) {
+		spinner.fail("Generation failed");
+		if (error instanceof Error) if (error.message.includes("Cannot find module")) {
+			console.error(pc.red("\nFailed to load grammar.ts"));
+			console.log(pc.dim("Ensure the file exists and has no syntax errors"));
+		} else if (error.message.includes("EACCES") || error.message.includes("EPERM")) {
+			console.error(pc.red("\nPermission denied writing to generated/"));
+			console.log(pc.dim("Check file permissions in the current directory"));
+		} else console.error(pc.red(`\n${error.message}`));
+		process.exit(1);
+	}
+}
+
+//#endregion
+//#region src/commands/build.ts
+async function build$1() {
+	const spinner = ora("Checking prerequisites...").start();
+	try {
+		const grammarPath = resolve(process.cwd(), "generated", "grammar.js");
+		if (!existsSync(grammarPath)) {
+			spinner.fail("generated/grammar.js not found");
+			console.log(pc.dim("\nRun \"treelsp generate\" first to create grammar.js"));
+			process.exit(1);
+		}
+		try {
+			execSync("tree-sitter --version", { stdio: "ignore" });
+		} catch {
+			spinner.fail("tree-sitter CLI not found");
+			console.log(pc.dim("\nInstall tree-sitter CLI:"));
+			console.log(pc.dim("  npm install -g tree-sitter-cli"));
+			console.log(pc.dim("  or: cargo install tree-sitter-cli"));
+			process.exit(1);
+		}
+		spinner.text = "Generating C parser...";
+		const genDir = resolve(process.cwd(), "generated");
+		const genPkgJson = resolve(genDir, "package.json");
+		const hadPkgJson = existsSync(genPkgJson);
+		if (!hadPkgJson) writeFileSync(genPkgJson, "{\"type\":\"commonjs\"}\n");
+		try {
+			execSync("tree-sitter generate generated/grammar.js", {
+				stdio: "pipe",
+				cwd: process.cwd()
+			});
+		} finally {
+			if (!hadPkgJson) rmSync(genPkgJson, { force: true });
+		}
+		spinner.text = "Compiling to WASM...";
+		execSync("tree-sitter build --wasm", {
+			stdio: "pipe",
+			cwd: process.cwd()
+		});
+		spinner.text = "Moving WASM output...";
+		const cwd = process.cwd();
+		const wasmFiles = readdirSync(cwd).filter((f) => f.startsWith("tree-sitter-") && f.endsWith(".wasm"));
+		if (wasmFiles.length === 0) {
+			spinner.fail("tree-sitter build --wasm did not produce a .wasm file");
+			process.exit(1);
+		}
+		const sourceWasm = resolve(cwd, wasmFiles[0]);
+		const destWasm = resolve(cwd, "generated", "grammar.wasm");
+		renameSync(sourceWasm, destWasm);
+		const cleanupDirs = ["src", "bindings"];
+		const cleanupFiles = [
+			"binding.gyp",
+			"Makefile",
+			"Package.swift",
+			".editorconfig"
+		];
+		for (const dir of cleanupDirs) {
+			const p = resolve(cwd, dir);
+			if (existsSync(p)) rmSync(p, {
+				recursive: true,
+				force: true
+			});
+		}
+		for (const file of cleanupFiles) {
+			const p = resolve(cwd, file);
+			if (existsSync(p)) rmSync(p, { force: true });
+		}
+		for (const f of readdirSync(cwd)) if (f.startsWith("tree-sitter-") && f.endsWith(".pc")) rmSync(resolve(cwd, f), { force: true });
+		spinner.text = "Bundling language server...";
+		const serverEntry = [
+			`import { startStdioServer } from 'treelsp/server';`,
+			`import { resolve, dirname } from 'node:path';`,
+			`import { fileURLToPath } from 'node:url';`,
+			`import definition from './grammar.ts';`,
+			``,
+			`const __dirname = dirname(fileURLToPath(import.meta.url));`,
+			`const wasmPath = resolve(__dirname, 'grammar.wasm');`,
+			``,
+			`startStdioServer({ definition, wasmPath });`
+		].join("\n");
+		const treelspServer = import.meta.resolve("treelsp/server");
+		const treelspPkg = resolve(new URL(treelspServer).pathname, "..", "..", "..");
+		const bundlePath = resolve(genDir, "server.bundle.cjs");
+		await build({
+			stdin: {
+				contents: serverEntry,
+				resolveDir: process.cwd(),
+				loader: "ts"
+			},
+			bundle: true,
+			format: "cjs",
+			platform: "node",
+			outfile: bundlePath,
+			sourcemap: true,
+			nodePaths: [resolve(treelspPkg, "node_modules")],
+			logLevel: "silent"
+		});
+		const { readFileSync } = await import("node:fs");
+		let bundleCode = readFileSync(bundlePath, "utf-8");
+		bundleCode = bundleCode.replace(/var import_meta\s*=\s*\{\s*\};/, "var import_meta = { url: require(\"url\").pathToFileURL(__filename).href };");
+		writeFileSync(bundlePath, bundleCode);
+		const treelspNodeModules = resolve(treelspPkg, "node_modules");
+		const tsWasmSrc = resolve(treelspNodeModules, "web-tree-sitter", "tree-sitter.wasm");
+		const tsWasmDest = resolve(genDir, "tree-sitter.wasm");
+		if (existsSync(tsWasmSrc) && !existsSync(tsWasmDest)) copyFileSync(tsWasmSrc, tsWasmDest);
+		spinner.succeed("Build complete");
+		console.log(pc.dim("\nGenerated files:"));
+		console.log(pc.dim("  generated/grammar.js"));
+		console.log(pc.dim("  generated/grammar.wasm"));
+		if (existsSync(resolve(genDir, "server.bundle.cjs"))) console.log(pc.dim("  generated/server.bundle.cjs"));
+	} catch (error) {
+		spinner.fail("Build failed");
+		if (error instanceof Error) {
+			const execError = error;
+			if (execError.stderr) {
+				const stderr = execError.stderr.toString();
+				console.error(pc.red("\nTree-sitter error:"));
+				console.error(pc.dim(stderr));
+				if (stderr.includes("grammar")) console.log(pc.dim("\nSuggestion: Check your grammar definition for errors"));
+				else if (stderr.includes("emcc") || stderr.includes("compiler")) {
+					console.log(pc.dim("\nSuggestion: Ensure Emscripten is installed for WASM compilation"));
+					console.log(pc.dim("  See: https://tree-sitter.github.io/tree-sitter/creating-parsers#tool-overview"));
+				}
+			} else console.error(pc.red(`\n${error.message}`));
+		}
+		process.exit(1);
+	}
+}
+
+//#endregion
+//#region src/commands/watch.ts
+async function watch() {
+	console.log(pc.bold("treelsp watch\n"));
+	if (!existsSync("grammar.ts")) {
+		console.error(pc.red("Could not find grammar.ts in current directory"));
+		console.log(pc.dim("\nRun \"treelsp init\" to create a new language project"));
+		process.exit(1);
+	}
+	const watcher = chokidar.watch("grammar.ts", {
+		persistent: true,
+		awaitWriteFinish: {
+			stabilityThreshold: 100,
+			pollInterval: 50
+		}
+	});
+	let isBuilding = false;
+	watcher.on("change", (path) => {
+		(async () => {
+			if (isBuilding) {
+				console.log(pc.dim("Build in progress, skipping..."));
+				return;
+			}
+			console.log(pc.dim(`\n${path} changed`));
+			isBuilding = true;
+			try {
+				await generate({});
+				await build$1();
+				console.log(pc.green("✓ Rebuild successful\n"));
+			} catch (_error) {
+				console.log(pc.red("✗ Rebuild failed\n"));
+			} finally {
+				isBuilding = false;
+				console.log(pc.dim("Watching for changes..."));
+			}
+		})();
+	});
+	watcher.on("error", (error) => {
+		console.error(pc.red("Watcher error:"), error instanceof Error ? error.message : String(error));
+	});
+	console.log(pc.dim("Running initial build...\n"));
+	try {
+		await generate({});
+		await build$1();
+		console.log(pc.green("✓ Initial build successful\n"));
+	} catch (_error) {
+		console.log(pc.red("✗ Initial build failed\n"));
+	}
+	console.log(pc.dim("Watching for changes..."));
+}
+
+//#endregion
+//#region src/index.ts
+const program = new Command();
+program.name("treelsp").description("CLI for treelsp - LSP generator using Tree-sitter").version("0.0.1");
+program.command("init").description("Scaffold a new language project").action(init);
+program.command("generate").description("Generate grammar.js, AST types, and server from language definition").option("-w, --watch", "Watch for changes").action(generate);
+program.command("build").description("Compile grammar.js to WASM using Tree-sitter CLI").action(build$1);
+program.command("watch").description("Watch mode - re-run generate + build on changes").action(watch);
+program.parse();
+
+//#endregion

package/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "@treelsp/cli",
+  "version": "0.0.1",
+  "publishConfig": {
+    "access": "public"
+  },
+  "description": "CLI tool for treelsp - LSP generator using Tree-sitter",
+  "type": "module",
+  "bin": {
+    "treelsp": "./dist/index.js"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "keywords": [
+    "lsp",
+    "cli",
+    "tree-sitter",
+    "codegen"
+  ],
+  "author": "Dhrubo Moy",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/dhrubomoy/treelsp.git",
+    "directory": "packages/cli"
+  },
+  "homepage": "https://github.com/dhrubomoy/treelsp#readme",
+  "bugs": "https://github.com/dhrubomoy/treelsp/issues",
+  "dependencies": {
+    "chokidar": "^4.0.3",
+    "commander": "^12.1.0",
+    "esbuild": "^0.27.3",
+    "ora": "^8.1.1",
+    "picocolors": "^1.1.1",
+    "prompts": "^2.4.2",
+    "treelsp": "0.0.1"
+  },
+  "devDependencies": {
+    "@types/prompts": "^2.4.9",
+    "tsdown": "^0.2.17",
+    "typescript": "^5.7.3"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "dev": "tsdown --watch",
+    "test": "vitest run --passWithNoTests",
+    "lint": "eslint src",
+    "clean": "rm -rf dist *.tsbuildinfo"
+  }
+}