@treelsp/cli 0.0.1 → 0.0.3

package/dist/index.js

@@ -1,42 +1,75 @@
 #!/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([{
-		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;
+	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;
+			}
+		},
+		{
+			type: "select",
+			name: "backend",
+			message: "Parser backend:",
+			choices: [{
+				title: "Tree-sitter",
+				description: "Default — generates WASM parser, requires tree-sitter CLI",
+				value: "tree-sitter"
+			}, {
+				title: "Lezer",
+				description: "Pure JavaScript — no external CLI required",
+				value: "lezer"
+			}],
+			initial: 0
 		}
-	}]);
-	if (!answers.name || !answers.extension) {
+	]);
+	if (!answers.name || !answers.extension || !answers.backend) {
 		console.log(pc.dim("\nCancelled"));
 		process.exit(0);
 	}
-	const { name, extension } = answers;
+	const { name, extension, backend } = answers;
+	const capitalizedName = name.split("-").map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join("");
+	const languageId = name.replace(/-/g, "").toLowerCase();
 	const spinner = ora("Creating project structure...").start();
 	try {
 		const projectDir = resolve(process.cwd(), name);
@@ -45,31 +78,178 @@ async function init() {
 			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 = `/**
+		await mkdir(resolve(projectDir, ".vscode"), { recursive: true });
+		await mkdir(resolve(projectDir, "packages", "language"), { recursive: true });
+		await mkdir(resolve(projectDir, "packages", "extension", "src"), { recursive: true });
+		const version = await getCliVersion();
+		const versionRange = `^${version}`;
+		const files = [
+			["pnpm-workspace.yaml", pnpmWorkspaceYaml()],
+			["package.json", rootPackageJson(name, versionRange)],
+			["treelsp-config.json", treelspConfigJson(backend)],
+			[".gitignore", rootGitignore()],
+			["README.md", rootReadme(capitalizedName, backend)],
+			[".vscode/launch.json", vscodeLaunchJson()],
+			[".vscode/tasks.json", vscodeTasksJson()],
+			["packages/language/package.json", languagePackageJson(name, versionRange)],
+			["packages/language/tsconfig.json", languageTsconfig()],
+			["packages/language/grammar.ts", grammarTemplate(capitalizedName, extension)],
+			["packages/extension/package.json", extensionPackageJson(name, capitalizedName, languageId, extension)],
+			["packages/extension/tsconfig.json", extensionTsconfig()],
+			["packages/extension/tsdown.config.ts", extensionTsdownConfig()],
+			["packages/extension/.vscodeignore", extensionVscodeignore()],
+			["packages/extension/src/extension.ts", extensionTs(capitalizedName, languageId)]
+		];
+		for (const [filePath, content] of files) await writeFile(resolve(projectDir, filePath), content, "utf-8");
+		spinner.succeed("Project created!");
+		console.log(pc.dim("\nNext steps:"));
+		console.log(pc.dim(`  cd ${name}`));
+		console.log(pc.dim("  pnpm install"));
+		console.log(pc.dim("  Edit packages/language/grammar.ts to define your language"));
+		console.log(pc.dim("  pnpm build"));
+		console.log(pc.dim("  Press F5 in VS Code to launch the extension"));
+	} catch (error) {
+		spinner.fail("Failed to create project");
+		if (error instanceof Error) console.error(pc.red(`\n${error.message}`));
+		process.exit(1);
+	}
+}
+function pnpmWorkspaceYaml() {
+	return `packages:\n  - 'packages/*'\n`;
+}
+function rootPackageJson(name, versionRange) {
+	const pkg = {
+		name,
+		version: "0.1.0",
+		private: true,
+		type: "module",
+		scripts: {
+			generate: "treelsp generate",
+			build: "treelsp generate && treelsp build",
+			"build:extension": `pnpm --filter ${name}-extension build`,
+			watch: "treelsp watch"
+		},
+		devDependencies: {
+			"@treelsp/cli": versionRange,
+			typescript: "^5.7.3"
+		}
+	};
+	return JSON.stringify(pkg, null, 2) + "\n";
+}
+function treelspConfigJson(backend) {
+	const entry = { grammar: "packages/language/grammar.ts" };
+	if (backend !== "tree-sitter") entry["backend"] = backend;
+	const config = { languages: [entry] };
+	return JSON.stringify(config, null, 2) + "\n";
+}
+function rootGitignore() {
+	return `node_modules
+dist
+generated/
+generated-lezer/
+*.wasm
+*.log
+*.tsbuildinfo
+.DS_Store
+`;
+}
+function rootReadme(capitalizedName, backend) {
+	const generatedDir = backend === "lezer" ? "generated-lezer" : "generated";
+	return `# ${capitalizedName}
+
+A language powered by [treelsp](https://github.com/dhrubomoy/treelsp) using the ${backend} parser backend.
+
+## Getting Started
+
+Install dependencies:
+
+\`\`\`bash
+pnpm install
+\`\`\`
+
+Generate grammar and build parser:
+
+\`\`\`bash
+pnpm build
+\`\`\`
+
+Launch the VS Code extension for development:
+
+\`\`\`
+Press F5 in VS Code, or:
+pnpm build:extension
+\`\`\`
+
+Development workflow:
+
+\`\`\`bash
+pnpm watch     # Auto-rebuild grammar on changes
+\`\`\`
+
+## Project Structure
+
+- \`packages/language/grammar.ts\` - Language definition (grammar, semantics, validation, LSP)
+- \`packages/language/${generatedDir}/\` - Generated files (parser, AST types, server bundle)
+- \`packages/extension/\` - VS Code extension that launches the language server
+
+## License
+
+MIT
+`;
+}
+function vscodeLaunchJson() {
+	const config = {
+		version: "0.2.0",
+		configurations: [{
+			name: "Launch Extension",
+			type: "extensionHost",
+			request: "launch",
+			args: ["--extensionDevelopmentPath=${workspaceFolder}/packages/extension", "${workspaceFolder}/packages/language"],
+			outFiles: ["${workspaceFolder}/packages/extension/dist/**/*.js"],
+			preLaunchTask: "build"
+		}]
+	};
+	return JSON.stringify(config, null, 2) + "\n";
+}
+function vscodeTasksJson() {
+	const config = {
+		version: "2.0.0",
+		tasks: [{
+			label: "build",
+			type: "shell",
+			command: "pnpm build && pnpm build:extension",
+			group: "build",
+			problemMatcher: []
+		}]
+	};
+	return JSON.stringify(config, null, 2) + "\n";
+}
+function languagePackageJson(name, versionRange) {
+	const pkg = {
+		name: `${name}-language`,
+		version: "0.1.0",
+		private: true,
+		type: "module",
+		dependencies: { treelsp: versionRange },
+		devDependencies: { typescript: "^5.7.3" }
+	};
+	return JSON.stringify(pkg, null, 2) + "\n";
+}
+function languageTsconfig() {
+	const config = {
+		compilerOptions: {
+			target: "ES2022",
+			module: "NodeNext",
+			moduleResolution: "NodeNext",
+			strict: true,
+			outDir: "./dist"
+		},
+		include: ["grammar.ts"]
+	};
+	return JSON.stringify(config, null, 2) + "\n";
+}
+function grammarTemplate(capitalizedName, extension) {
+	return `/**
  * ${capitalizedName} - Language definition for treelsp
  */
 
@@ -164,208 +344,413 @@ export default defineLanguage({
   },
 });
 `;
-		await writeFile(resolve(projectDir, "grammar.ts"), grammarTemplate, "utf-8");
-		const gitignore = `node_modules
-dist
-generated/
-*.wasm
-*.log
+}
+function extensionPackageJson(name, capitalizedName, languageId, extension) {
+	const pkg = {
+		name: `${name}-extension`,
+		displayName: capitalizedName,
+		description: `VS Code extension for ${capitalizedName}`,
+		version: "0.1.0",
+		private: true,
+		publisher: name,
+		engines: { vscode: "^1.80.0" },
+		categories: ["Programming Languages"],
+		activationEvents: ["workspaceContains:**/generated/treelsp.json", "workspaceContains:**/generated-lezer/treelsp.json"],
+		main: "./dist/extension.js",
+		contributes: { languages: [{
+			id: languageId,
+			extensions: [extension],
+			aliases: [capitalizedName]
+		}] },
+		scripts: {
+			build: "tsdown",
+			dev: "tsdown --watch",
+			package: "vsce package"
+		},
+		dependencies: { "vscode-languageclient": "^9.0.1" },
+		devDependencies: {
+			"@types/vscode": "^1.80.0",
+			tsdown: "^0.2.17",
+			typescript: "^5.7.3"
+		}
+	};
+	return JSON.stringify(pkg, null, 2) + "\n";
+}
+function extensionTsconfig() {
+	const config = {
+		compilerOptions: {
+			target: "ES2022",
+			module: "NodeNext",
+			moduleResolution: "NodeNext",
+			strict: true,
+			outDir: "./dist",
+			rootDir: "./src",
+			lib: ["ES2022"]
+		},
+		include: ["src/**/*"],
+		exclude: ["node_modules", "dist"]
+	};
+	return JSON.stringify(config, null, 2) + "\n";
+}
+function extensionTsdownConfig() {
+	return `import { defineConfig } from 'tsdown';
+
+export default defineConfig({
+  entry: ['src/extension.ts'],
+  format: ['cjs'],
+  dts: false,
+  clean: true,
+  platform: 'node',
+  external: ['vscode'],
+});
+`;
+}
+function extensionVscodeignore() {
+	return `src/
+node_modules/
+.gitignore
+tsconfig.json
+tsdown.config.ts
 *.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:
+}
+function extensionTs(capitalizedName, languageId) {
+	return `/**
+ * ${capitalizedName} - VS Code Extension
+ * Discovers and launches the treelsp-generated language server.
+ */
 
-\`\`\`bash
-npm run watch     # Auto-rebuild on changes
-\`\`\`
+import * as vscode from 'vscode';
+import * as path from 'path';
+import * as fs from 'fs';
+import {
+  LanguageClient,
+  LanguageClientOptions,
+  ServerOptions,
+  TransportKind,
+  State,
+} from 'vscode-languageclient/node';
+
+interface TreelspManifest {
+  name: string;
+  languageId: string;
+  fileExtensions: string[];
+  server: string;
+  textmateGrammar?: string;
+}
 
-## Project Structure
+const clients = new Map<string, LanguageClient>();
+
+export async function activate(context: vscode.ExtensionContext) {
+  const manifests = await discoverManifests();
+
+  for (const { manifest, manifestPath } of manifests) {
+    await startLanguageClient(manifest, manifestPath, context);
+  }
+
+  // Watch for new or updated manifests
+  for (const pattern of ['**/generated/treelsp.json', '**/generated-lezer/treelsp.json']) {
+    const watcher = vscode.workspace.createFileSystemWatcher(pattern);
+    watcher.onDidCreate(async (uri) => {
+      const data = await readManifest(uri.fsPath);
+      if (data) await startLanguageClient(data, uri.fsPath, context);
+    });
+    watcher.onDidChange(async (uri) => {
+      await stopClient(uri.fsPath);
+      const data = await readManifest(uri.fsPath);
+      if (data) await startLanguageClient(data, uri.fsPath, context);
+    });
+    watcher.onDidDelete(async (uri) => {
+      await stopClient(uri.fsPath);
+    });
+    context.subscriptions.push(watcher);
+  }
+}
 
-- \`grammar.ts\` - Language definition (grammar, semantic, validation, LSP)
-- \`generated/\` - Generated files (grammar.js, WASM, types)
-- \`package.json\` - Project dependencies
+export async function deactivate(): Promise<void> {
+  const stops = [...clients.values()].map(c => c.stop());
+  await Promise.all(stops);
+  clients.clear();
+}
 
-## Documentation
+async function discoverManifests(): Promise<Array<{ manifest: TreelspManifest; manifestPath: string }>> {
+  const results: Array<{ manifest: TreelspManifest; manifestPath: string }> = [];
+  for (const pattern of ['**/generated/treelsp.json', '**/generated-lezer/treelsp.json']) {
+    const uris = await vscode.workspace.findFiles(pattern, '**/node_modules/**');
+    for (const uri of uris) {
+      const data = await readManifest(uri.fsPath);
+      if (data) results.push({ manifest: data, manifestPath: uri.fsPath });
+    }
+  }
+  return results;
+}
 
-- [treelsp Documentation](https://github.com/yourusername/treelsp)
-- [Tree-sitter](https://tree-sitter.github.io/tree-sitter/)
+async function readManifest(fsPath: string): Promise<TreelspManifest | null> {
+  try {
+    const doc = await vscode.workspace.openTextDocument(fsPath);
+    const data = JSON.parse(doc.getText()) as TreelspManifest;
+    if (!data.name || !data.languageId || !data.fileExtensions || !data.server) return null;
+    return data;
+  } catch {
+    return null;
+  }
+}
 
-## License
+async function startLanguageClient(
+  manifest: TreelspManifest,
+  manifestPath: string,
+  context: vscode.ExtensionContext,
+): Promise<void> {
+  if (clients.has(manifestPath)) return;
+
+  const generatedDir = path.dirname(manifestPath);
+  const serverModule = path.resolve(generatedDir, manifest.server);
+
+  if (!fs.existsSync(serverModule)) {
+    void vscode.window.showErrorMessage(
+      '${capitalizedName}: Server bundle not found. Run "pnpm build" first.',
+    );
+    return;
+  }
+
+  const serverOptions: ServerOptions = {
+    run: { module: serverModule, transport: TransportKind.stdio },
+    debug: {
+      module: serverModule,
+      transport: TransportKind.stdio,
+      options: { execArgv: ['--nolazy', '--inspect=6009'] },
+    },
+  };
+
+  const clientOptions: LanguageClientOptions = {
+    documentSelector: manifest.fileExtensions.map(ext => ({
+      scheme: 'file' as const,
+      language: manifest.languageId,
+      pattern: \`**/*\${ext}\`,
+    })),
+    outputChannelName: '${capitalizedName} Language Server',
+  };
+
+  const client = new LanguageClient(
+    '${languageId}',
+    '${capitalizedName} Language Server',
+    serverOptions,
+    clientOptions,
+  );
+
+  client.onDidChangeState((event) => {
+    if (event.oldState === State.Running && event.newState === State.Stopped) {
+      void vscode.window.showWarningMessage(
+        '${capitalizedName}: Language server stopped unexpectedly.',
+      );
+    }
+  });
+
+  clients.set(manifestPath, client);
+  context.subscriptions.push(client);
+
+  try {
+    await client.start();
+  } catch (e) {
+    clients.delete(manifestPath);
+    void vscode.window.showErrorMessage(
+      \`${capitalizedName}: Failed to start language server: \${e instanceof Error ? e.message : String(e)}\`,
+    );
+  }
+}
 
-MIT
+async function stopClient(key: string): Promise<void> {
+  const client = clients.get(key);
+  if (!client) return;
+  await client.stop();
+  clients.delete(key);
+}
 `;
-		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/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 +759,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 +823,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 +849,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))
+		};
+	}
+	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;
 	}
-	console.log(pc.dim("Watching for changes..."));
+	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 +966,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