@treelsp/cli 0.0.1 → 0.0.2

package/README.md

@@ -0,0 +1,139 @@
+# @treelsp/cli
+
+CLI tool for [treelsp](https://github.com/dhrubomoy/treelsp) — generate Tree-sitter grammars, WASM parsers, and language servers from TypeScript definitions.
+
+## Installation
+
+```bash
+npm install -D @treelsp/cli
+# or
+pnpm add -D @treelsp/cli
+```
+
+## Commands
+
+### `treelsp init`
+
+Scaffold a new language project interactively.
+
+```bash
+treelsp init
+```
+
+Prompts for a language name and file extension, then creates a project directory with:
+- `grammar.ts` — language definition template
+- `package.json` — dependencies and scripts
+- `tsconfig.json` — TypeScript configuration
+- `.gitignore`
+
+### `treelsp generate`
+
+Generate grammar.js, AST types, manifest, and syntax highlighting queries from a language definition.
+
+```
+Usage: treelsp generate [options]
+
+Options:
+  -f, --file <file>  path to treelsp-config.json or package.json with treelsp field
+  -w, --watch        watch for changes
+```
+
+**Output files** (written to the output directory, default `generated/`):
+- `grammar.js` — Tree-sitter grammar (CommonJS)
+- `ast.ts` — typed AST interfaces
+- `treelsp.json` — manifest for VS Code extension discovery
+- `queries/highlights.scm` — Tree-sitter syntax highlighting
+- `queries/locals.scm` — Tree-sitter scope/locals
+
+### `treelsp build`
+
+Compile the generated grammar to WASM and bundle the language server.
+
+```
+Usage: treelsp build [options]
+
+Options:
+  -f, --file <file>  path to treelsp-config.json or package.json with treelsp field
+```
+
+Requires the [tree-sitter CLI](https://github.com/tree-sitter/tree-sitter/blob/master/cli/README.md) to be installed (`npm install -g tree-sitter-cli` or `cargo install tree-sitter-cli`).
+
+**Output files:**
+- `grammar.wasm` — compiled WebAssembly parser
+- `server.bundle.cjs` — self-contained language server bundle
+- `tree-sitter.wasm` — web-tree-sitter runtime
+
+### `treelsp watch`
+
+Watch mode — re-runs `generate` + `build` automatically when grammar files change.
+
+```
+Usage: treelsp watch [options]
+
+Options:
+  -f, --file <file>  path to treelsp-config.json or package.json with treelsp field
+```
+
+## Configuration
+
+By default, treelsp looks for `grammar.ts` in the current directory and outputs to `generated/`. For multi-language projects, create a config file to specify all languages.
+
+### Config discovery order
+
+When `-f` is not provided, the CLI searches from the current directory upward for:
+
+1. `treelsp-config.json`
+2. A `"treelsp"` field in `package.json`
+3. Falls back to legacy mode (`grammar.ts` in cwd)
+
+### `treelsp-config.json`
+
+```json
+{
+  "languages": [
+    { "grammar": "mini-lang/grammar.ts" },
+    { "grammar": "schema-lang/grammar.ts" }
+  ]
+}
+```
+
+### `package.json`
+
+```json
+{
+  "treelsp": {
+    "languages": [
+      { "grammar": "src/grammar.ts", "out": "src/generated" }
+    ]
+  }
+}
+```
+
+### Schema
+
+| Field | Type | Required | Description |
+|-------|------|----------|-------------|
+| `languages` | array | yes | List of language projects |
+| `languages[].grammar` | string | yes | Path to `grammar.ts`, relative to the config file |
+| `languages[].out` | string | no | Output directory (default: `<grammar dir>/generated`) |
+
+## Typical Workflow
+
+**Single language (no config needed):**
+
+```bash
+treelsp init           # scaffold project
+cd my-lang
+npm install
+treelsp generate       # generate grammar.js, ast.ts, etc.
+treelsp build          # compile WASM + bundle server
+```
+
+**Multi-language monorepo:**
+
+```bash
+# treelsp-config.json at repo root
+treelsp generate       # generates all languages
+treelsp build          # builds all languages
+treelsp watch          # watches all grammar files
+```

package/bin/treelsp.js

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+await import('../dist/index.js');

package/dist/index.js

@@ -1,18 +1,31 @@
 #!/usr/bin/env node
 import { Command } from "commander";
+import pc from "picocolors";
 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 { mkdir, readFile, writeFile } from "node:fs/promises";
+import { basename, dirname, relative, resolve } from "node:path";
+import { copyFileSync, existsSync, readFileSync, readdirSync, rmSync, unlinkSync } from "node:fs";
+import { fileURLToPath, pathToFileURL } from "node:url";
 import { build } from "esbuild";
+import { generateAstTypes, generateManifest, generateTextmate } from "treelsp/codegen";
 import chokidar from "chokidar";
 
 //#region src/commands/init.ts
+/**
+* Read the CLI package version at runtime so scaffolded projects
+* always pin to the version of the CLI that created them.
+*/
+async function getCliVersion() {
+	try {
+		const distDir = dirname(fileURLToPath(import.meta.url));
+		const pkgPath = resolve(distDir, "..", "package.json");
+		const pkg = JSON.parse(await readFile(pkgPath, "utf-8"));
+		return pkg.version;
+	} catch {
+		return "0.0.1";
+	}
+}
 async function init() {
 	console.log(pc.bold("treelsp init\n"));
 	const answers = await prompts([{
@@ -46,13 +59,15 @@ async function init() {
 			process.exit(1);
 		}
 		await mkdir(projectDir);
+		const version = await getCliVersion();
+		const versionRange = `^${version}`;
 		const packageJson = {
 			name,
 			version: "0.1.0",
 			type: "module",
-			dependencies: { treelsp: "^0.0.1" },
+			dependencies: { treelsp: versionRange },
 			devDependencies: {
-				"@treelsp/cli": "^0.0.1",
+				"@treelsp/cli": versionRange,
 				typescript: "^5.7.3"
 			},
 			scripts: {
@@ -63,8 +78,13 @@ async function init() {
 		};
 		await writeFile(resolve(projectDir, "package.json"), JSON.stringify(packageJson, null, 2) + "\n", "utf-8");
 		const tsconfig = {
-			extends: "treelsp/tsconfig.base.json",
-			compilerOptions: { outDir: "./dist" },
+			compilerOptions: {
+				target: "ES2022",
+				module: "NodeNext",
+				moduleResolution: "NodeNext",
+				strict: true,
+				outDir: "./dist"
+			},
 			include: ["grammar.ts"]
 		};
 		await writeFile(resolve(projectDir, "tsconfig.json"), JSON.stringify(tsconfig, null, 2) + "\n", "utf-8");
@@ -230,142 +250,189 @@ MIT
 	}
 }
 
+//#endregion
+//#region src/backends.ts
+const treeSitterBin = resolve(dirname(fileURLToPath(import.meta.resolve("tree-sitter-cli/cli.js"))), "tree-sitter");
+const BACKENDS = {
+	"tree-sitter": async () => {
+		const { TreeSitterCodegen } = await import("treelsp/codegen/tree-sitter");
+		return new TreeSitterCodegen({ treeSitterBin });
+	},
+	"lezer": async () => {
+		const { LezerCodegen } = await import("treelsp/codegen/lezer");
+		return new LezerCodegen();
+	}
+};
+/**
+* Resolve a codegen backend by identifier.
+* Defaults to "tree-sitter" if not specified.
+*/
+async function getCodegenBackend(id = "tree-sitter") {
+	const factory = BACKENDS[id];
+	if (!factory) {
+		const available = Object.keys(BACKENDS).join(", ");
+		throw new Error(`Unknown parser backend: "${id}". Available backends: ${available}`);
+	}
+	return factory();
+}
+
 //#endregion
 //#region src/commands/generate.ts
-async function generate(options) {
-	const spinner = ora("Loading grammar.ts...").start();
+/**
+* Generate code for a single language project.
+*/
+async function generateProject(project) {
+	const label = relative(process.cwd(), project.grammarPath) || project.grammarPath;
+	const spinner = ora(`Loading ${label}...`).start();
 	try {
-		const grammarPath = resolve(process.cwd(), "grammar.ts");
-		if (!existsSync(grammarPath)) {
-			spinner.fail("Could not find grammar.ts in current directory");
+		if (!existsSync(project.grammarPath)) {
+			spinner.fail(`Could not find ${label}`);
 			console.log(pc.dim("\nRun \"treelsp init\" to create a new language project"));
-			process.exit(1);
+			throw new Error(`Grammar file not found: ${project.grammarPath}`);
+		}
+		const tmpPath = project.grammarPath.replace(/\.ts$/, ".tmp.mjs");
+		await build({
+			entryPoints: [project.grammarPath],
+			bundle: true,
+			format: "esm",
+			platform: "node",
+			outfile: tmpPath,
+			packages: "external",
+			logLevel: "silent"
+		});
+		let definition;
+		try {
+			const grammarUrl = pathToFileURL(tmpPath).href;
+			const mod = await import(grammarUrl);
+			definition = mod.default;
+		} finally {
+			try {
+				unlinkSync(tmpPath);
+			} catch {}
 		}
-		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);
+			throw new Error("Invalid language definition");
 		}
 		spinner.text = `Generating code for ${definition.name}...`;
-		const grammarJs = generateGrammar(definition);
+		const backend = await getCodegenBackend(project.backend);
+		const artifacts = backend.generate(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 });
+		const textmateGrammar = generateTextmate(definition);
+		await mkdir(project.outDir, { recursive: true });
+		const artifactDirs = new Set(artifacts.map((a) => a.path.includes("/") ? resolve(project.outDir, a.path, "..") : null).filter((d) => d !== null));
+		for (const dir of artifactDirs) await mkdir(dir, { 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")
+			...artifacts.map((a) => writeFile(resolve(project.outDir, a.path), a.content, "utf-8")),
+			writeFile(resolve(project.outDir, "ast.ts"), astTypes, "utf-8"),
+			writeFile(resolve(project.outDir, "treelsp.json"), manifest, "utf-8"),
+			writeFile(resolve(project.outDir, "syntax.tmLanguage.json"), textmateGrammar, "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"));
+		const outLabel = relative(process.cwd(), project.outDir) || project.outDir;
+		spinner.succeed(`Generated ${definition.name} -> ${outLabel}/`);
 	} catch (error) {
-		spinner.fail("Generation failed");
+		if (!spinner.isSpinning) {} else spinner.fail(`Generation failed for ${label}`);
 		if (error instanceof Error) if (error.message.includes("Cannot find module")) {
-			console.error(pc.red("\nFailed to load grammar.ts"));
+			console.error(pc.red("\nFailed to load grammar file"));
 			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"));
+			console.error(pc.red(`\nPermission denied writing to ${project.outDir}`));
+			console.log(pc.dim("Check file permissions"));
 		} else console.error(pc.red(`\n${error.message}`));
-		process.exit(1);
+		throw error;
 	}
 }
+/**
+* Top-level generate command handler.
+*/
+async function generate(options, configResult) {
+	for (const project of configResult.projects) await generateProject(project);
+	if (!options.watch) console.log(pc.dim("\nNext step: Run \"treelsp build\" to compile grammar to WASM"));
+}
 
 //#endregion
 //#region src/commands/build.ts
-async function build$1() {
-	const spinner = ora("Checking prerequisites...").start();
+/**
+* Map from backend id to the runtime import specifier used in the server entry.
+*/
+const BACKEND_RUNTIME_IMPORT = {
+	"tree-sitter": {
+		specifier: "treelsp/backend/tree-sitter",
+		className: "TreeSitterRuntime"
+	},
+	"lezer": {
+		specifier: "treelsp/backend/lezer",
+		className: "LezerRuntime"
+	}
+};
+/**
+* Build a single language project: compile parser + bundle server.
+*/
+async function buildProject(project) {
+	const label = relative(process.cwd(), project.projectDir) || project.projectDir;
+	const spinner = ora(`Building ${label}...`).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 });
+		const backend = await getCodegenBackend(project.backend);
+		spinner.text = `Compiling parser for ${label}...`;
+		await backend.compile(project.projectDir, project.outDir, { onProgress: (msg) => {
+			spinner.text = `${msg} (${label})`;
+		} });
+		if (backend.cleanupPatterns) {
+			const { directories, files, globs } = backend.cleanupPatterns;
+			if (directories) for (const dir of directories) {
+				const p = resolve(project.projectDir, dir);
+				if (existsSync(p)) rmSync(p, {
+					recursive: true,
+					force: true
+				});
+			}
+			if (files) for (const file of files) {
+				const p = resolve(project.projectDir, file);
+				if (existsSync(p)) rmSync(p, { force: true });
+			}
+			if (globs) for (const pattern of globs) {
+				const parts = pattern.split("*");
+				if (parts.length === 2) {
+					const [prefix, suffix] = parts;
+					for (const f of readdirSync(project.projectDir)) if (f.startsWith(prefix) && f.endsWith(suffix)) rmSync(resolve(project.projectDir, f), { 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 = [
+		spinner.text = `Bundling language server for ${label}...`;
+		const runtimeImport = BACKEND_RUNTIME_IMPORT[project.backend];
+		if (!runtimeImport) throw new Error(`No runtime import configured for backend "${project.backend}"`);
+		let serverEntry;
+		if (project.backend === "lezer") {
+			const relOut = "./" + relative(project.projectDir, project.outDir).replace(/\\/g, "/");
+			serverEntry = [
+				`import { startStdioServer } from 'treelsp/server';`,
+				`import { ${runtimeImport.className} } from '${runtimeImport.specifier}';`,
+				`import definition from './grammar.ts';`,
+				`import { parser } from '${relOut}/parser.bundle.js';`,
+				`import parserMeta from '${relOut}/parser-meta.json';`,
+				``,
+				`const backend = new ${runtimeImport.className}(parser, parserMeta);`,
+				`startStdioServer({ definition, parserPath: '', backend });`
+			].join("\n");
+		} else serverEntry = [
 			`import { startStdioServer } from 'treelsp/server';`,
-			`import { resolve, dirname } from 'node:path';`,
-			`import { fileURLToPath } from 'node:url';`,
+			`import { ${runtimeImport.className} } from '${runtimeImport.specifier}';`,
+			`import { resolve } from 'node:path';`,
 			`import definition from './grammar.ts';`,
 			``,
-			`const __dirname = dirname(fileURLToPath(import.meta.url));`,
-			`const wasmPath = resolve(__dirname, 'grammar.wasm');`,
+			`const parserPath = resolve(__dirname, 'grammar.wasm');`,
 			``,
-			`startStdioServer({ definition, wasmPath });`
+			`startStdioServer({ definition, parserPath, backend: new ${runtimeImport.className}() });`
 		].join("\n");
 		const treelspServer = import.meta.resolve("treelsp/server");
 		const treelspPkg = resolve(new URL(treelspServer).pathname, "..", "..", "..");
-		const bundlePath = resolve(genDir, "server.bundle.cjs");
+		const bundlePath = resolve(project.outDir, "server.bundle.cjs");
 		await build({
 			stdin: {
 				contents: serverEntry,
-				resolveDir: process.cwd(),
+				resolveDir: project.projectDir,
 				loader: "ts"
 			},
 			bundle: true,
@@ -374,50 +441,63 @@ async function build$1() {
 			outfile: bundlePath,
 			sourcemap: true,
 			nodePaths: [resolve(treelspPkg, "node_modules")],
-			logLevel: "silent"
+			logLevel: "warning",
+			logOverride: { "empty-import-meta": "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"));
+		if (backend.getRuntimeFiles) for (const { src, dest } of backend.getRuntimeFiles(treelspPkg)) {
+			const destPath = resolve(project.outDir, dest);
+			if (existsSync(src) && !existsSync(destPath)) copyFileSync(src, destPath);
+		}
+		const outLabel = relative(process.cwd(), project.outDir) || project.outDir;
+		spinner.succeed(`Built ${label} -> ${outLabel}/`);
 	} catch (error) {
-		spinner.fail("Build failed");
+		spinner.fail(`Build failed for ${label}`);
 		if (error instanceof Error) {
+			const esbuildError = error;
 			const execError = error;
-			if (execError.stderr) {
+			if (esbuildError.errors && esbuildError.errors.length > 0) {
+				console.error(pc.red("\nServer bundling failed:"));
+				for (const err of esbuildError.errors) {
+					const loc = err.location ? ` (${err.location.file}:${err.location.line})` : "";
+					console.error(pc.dim(`  ${err.text}${loc}`));
+				}
+			} else if (execError.stderr) {
 				const stderr = execError.stderr.toString();
-				console.error(pc.red("\nTree-sitter error:"));
+				console.error(pc.red("\nBackend compilation 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);
+		throw error;
 	}
 }
+/**
+* Top-level build command handler.
+*/
+async function build$1(configResult) {
+	for (const project of configResult.projects) await buildProject(project);
+}
 
 //#endregion
 //#region src/commands/watch.ts
-async function watch() {
+async function watch(configResult) {
 	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 { projects } = configResult;
+	const projectByGrammar = /* @__PURE__ */ new Map();
+	const grammarPaths = [];
+	for (const project of projects) {
+		if (!existsSync(project.grammarPath)) {
+			console.error(pc.red(`Could not find ${relative(process.cwd(), project.grammarPath)}`));
+			process.exit(1);
+		}
+		projectByGrammar.set(project.grammarPath, project);
+		grammarPaths.push(project.grammarPath);
+	}
+	if (projects.length > 1) {
+		console.log(pc.dim(`Watching ${String(projects.length)} language projects:`));
+		for (const p of projects) console.log(pc.dim(`  - ${relative(process.cwd(), p.grammarPath)}`));
+		console.log("");
 	}
-	const watcher = chokidar.watch("grammar.ts", {
+	const watcher = chokidar.watch(grammarPaths, {
 		persistent: true,
 		awaitWriteFinish: {
 			stabilityThreshold: 100,
@@ -425,20 +505,22 @@ async function watch() {
 		}
 	});
 	let isBuilding = false;
-	watcher.on("change", (path) => {
+	watcher.on("change", (changedPath) => {
 		(async () => {
 			if (isBuilding) {
 				console.log(pc.dim("Build in progress, skipping..."));
 				return;
 			}
-			console.log(pc.dim(`\n${path} changed`));
+			const project = projectByGrammar.get(changedPath);
+			if (!project) return;
+			console.log(pc.dim(`\n${relative(process.cwd(), changedPath)} 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"));
+				await generateProject(project);
+				await buildProject(project);
+				console.log(pc.green("  Rebuild successful\n"));
+			} catch {
+				console.log(pc.red("  Rebuild failed\n"));
 			} finally {
 				isBuilding = false;
 				console.log(pc.dim("Watching for changes..."));
@@ -449,14 +531,116 @@ async function watch() {
 		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"));
+	for (const project of projects) try {
+		await generateProject(project);
+		await buildProject(project);
+	} catch {
+		console.log(pc.red(`  ${relative(process.cwd(), project.projectDir)} - FAILED\n`));
+	}
+	console.log(pc.dim("\nWatching for changes..."));
+}
+
+//#endregion
+//#region src/config.ts
+/**
+* Resolve config: use -f flag, auto-discover, or fall back to legacy.
+*/
+function resolveConfig(fileFlag) {
+	if (fileFlag) return loadConfigFromFile(fileFlag);
+	const discovered = discoverConfig();
+	if (discovered) return discovered;
+	const cwd = process.cwd();
+	return {
+		source: "legacy",
+		projects: [{
+			grammarPath: resolve(cwd, "grammar.ts"),
+			projectDir: cwd,
+			outDir: resolve(cwd, "generated"),
+			backend: "tree-sitter"
+		}]
+	};
+}
+function loadConfigFromFile(filePath) {
+	const absPath = resolve(filePath);
+	if (!existsSync(absPath)) throw new Error(`Config file not found: ${absPath}`);
+	const raw = readFileSync(absPath, "utf-8");
+	if (basename(absPath) === "package.json") {
+		const pkg = JSON.parse(raw);
+		const treelspField = pkg["treelsp"];
+		if (!treelspField) throw new Error(`No "treelsp" field found in ${absPath}`);
+		const config$1 = validateConfig(treelspField, absPath);
+		return {
+			source: "package.json",
+			configPath: absPath,
+			projects: resolveProjects(config$1, dirname(absPath))
+		};
 	}
-	console.log(pc.dim("Watching for changes..."));
+	const config = validateConfig(JSON.parse(raw), absPath);
+	return {
+		source: "file",
+		configPath: absPath,
+		projects: resolveProjects(config, dirname(absPath))
+	};
+}
+function discoverConfig() {
+	let dir = resolve(process.cwd());
+	while (true) {
+		const configFile = resolve(dir, "treelsp-config.json");
+		if (existsSync(configFile)) {
+			const raw = readFileSync(configFile, "utf-8");
+			const config = validateConfig(JSON.parse(raw), configFile);
+			return {
+				source: "file",
+				configPath: configFile,
+				projects: resolveProjects(config, dir)
+			};
+		}
+		const pkgFile = resolve(dir, "package.json");
+		if (existsSync(pkgFile)) {
+			const raw = readFileSync(pkgFile, "utf-8");
+			const pkg = JSON.parse(raw);
+			if (pkg["treelsp"]) {
+				const config = validateConfig(pkg["treelsp"], pkgFile);
+				return {
+					source: "package.json",
+					configPath: pkgFile,
+					projects: resolveProjects(config, dir)
+				};
+			}
+		}
+		const parent = dirname(dir);
+		if (parent === dir) break;
+		dir = parent;
+	}
+	return null;
+}
+function validateConfig(raw, filePath) {
+	if (typeof raw !== "object" || raw === null) throw new Error(`Invalid config in ${filePath}: expected an object`);
+	const obj = raw;
+	if (!Array.isArray(obj["languages"])) throw new Error(`Invalid config in ${filePath}: "languages" must be an array`);
+	const languages = obj["languages"];
+	if (languages.length === 0) throw new Error(`Invalid config in ${filePath}: "languages" must not be empty`);
+	for (let i = 0; i < languages.length; i++) {
+		const lang = languages[i];
+		if (typeof lang !== "object" || lang === null) throw new Error(`Invalid config in ${filePath}: languages[${String(i)}] must be an object`);
+		const langObj = lang;
+		if (typeof langObj["grammar"] !== "string" || langObj["grammar"].length === 0) throw new Error(`Invalid config in ${filePath}: languages[${String(i)}].grammar must be a non-empty string`);
+		if (langObj["out"] !== void 0 && (typeof langObj["out"] !== "string" || langObj["out"].length === 0)) throw new Error(`Invalid config in ${filePath}: languages[${String(i)}].out must be a non-empty string if provided`);
+	}
+	return obj;
+}
+function resolveProjects(config, configDir) {
+	return config.languages.map((lang) => {
+		const grammarPath = resolve(configDir, lang.grammar);
+		const projectDir = dirname(grammarPath);
+		const outDir = lang.out ? resolve(configDir, lang.out) : resolve(projectDir, "generated");
+		return {
+			grammarPath,
+			projectDir,
+			outDir,
+			backend: lang.backend ?? "tree-sitter"
+		};
+	});
 }
 
 //#endregion
@@ -464,9 +648,29 @@ async function watch() {
 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.command("generate").description("Generate grammar.js, AST types, and server from language definition").option("-f, --file <file>", "Path to treelsp-config.json or package.json with treelsp field").option("-w, --watch", "Watch for changes").action(async (options) => {
+	try {
+		const config = resolveConfig(options.file);
+		if (config.configPath) console.log(pc.dim(`Using config: ${config.configPath}\n`));
+		await generate(options, config);
+	} catch {
+		process.exit(1);
+	}
+});
+program.command("build").description("Compile grammar.js to WASM using Tree-sitter CLI").option("-f, --file <file>", "Path to treelsp-config.json or package.json with treelsp field").action(async (options) => {
+	try {
+		const config = resolveConfig(options.file);
+		if (config.configPath) console.log(pc.dim(`Using config: ${config.configPath}\n`));
+		await build$1(config);
+	} catch {
+		process.exit(1);
+	}
+});
+program.command("watch").description("Watch mode - re-run generate + build on changes").option("-f, --file <file>", "Path to treelsp-config.json or package.json with treelsp field").action(async (options) => {
+	const config = resolveConfig(options.file);
+	if (config.configPath) console.log(pc.dim(`Using config: ${config.configPath}\n`));
+	await watch(config);
+});
 program.parse();
 
 //#endregion

package/package.json

@@ -1,16 +1,17 @@
 {
   "name": "@treelsp/cli",
-  "version": "0.0.1",
+  "version": "0.0.2",
   "publishConfig": {
     "access": "public"
   },
   "description": "CLI tool for treelsp - LSP generator using Tree-sitter",
   "type": "module",
   "bin": {
-    "treelsp": "./dist/index.js"
+    "treelsp": "./bin/treelsp.js"
   },
   "files": [
     "dist",
+    "bin",
     "README.md"
   ],
   "keywords": [
@@ -21,6 +22,9 @@
   ],
   "author": "Dhrubo Moy",
   "license": "MIT",
+  "engines": {
+    "node": ">=20"
+  },
   "repository": {
     "type": "git",
     "url": "https://github.com/dhrubomoy/treelsp.git",
@@ -29,13 +33,15 @@
   "homepage": "https://github.com/dhrubomoy/treelsp#readme",
   "bugs": "https://github.com/dhrubomoy/treelsp/issues",
   "dependencies": {
+    "@lezer/generator": "^1.8.0",
     "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"
+    "tree-sitter-cli": "^0.26.5",
+    "treelsp": "0.0.2"
   },
   "devDependencies": {
     "@types/prompts": "^2.4.9",