zedx 0.6.0 → 0.8.0

package/dist/prompts.js

@@ -5,7 +5,7 @@ export async function promptUser() {
     const nameDefault = 'my-zed-extension';
     const name = await p.text({
         message: 'Project name:',
-        placeholder: nameDefault
+        placeholder: nameDefault,
     });
     if (p.isCancel(name)) {
         p.cancel('Cancelled.');
@@ -21,7 +21,7 @@ export async function promptUser() {
                 return 'ID cannot contain spaces';
             if (value && value !== value.toLowerCase())
                 return 'ID must be lowercase';
-        }
+        },
     });
     if (p.isCancel(id)) {
         p.cancel('Cancelled.');
@@ -31,7 +31,7 @@ export async function promptUser() {
     const descriptionDefault = 'A Zed extension';
     const description = await p.text({
         message: 'Description:',
-        placeholder: descriptionDefault
+        placeholder: descriptionDefault,
     });
     if (p.isCancel(description)) {
         p.cancel('Cancelled.');
@@ -44,7 +44,7 @@ export async function promptUser() {
         validate: (value) => {
             if (!value || value.length === 0)
                 return 'Author is required';
-        }
+        },
     });
     if (p.isCancel(author)) {
         p.cancel('Cancelled.');
@@ -53,7 +53,7 @@ export async function promptUser() {
     const repositoryDefault = `https://github.com/username/${idValue}.git`;
     const repository = await p.text({
         message: 'GitHub repository URL:',
-        initialValue: repositoryDefault
+        initialValue: repositoryDefault,
     });
     if (p.isCancel(repository)) {
         p.cancel('Cancelled.');
@@ -69,9 +69,9 @@ export async function promptUser() {
             { value: 'GPL-3.0', label: 'GNU GPLv3' },
             { value: 'LGPL-3.0', label: 'GNU LGPLv3' },
             { value: 'MIT', label: 'MIT' },
-            { value: 'Zlib', label: 'zlib' }
+            { value: 'Zlib', label: 'zlib' },
         ],
-        initialValue: 'MIT'
+        initialValue: 'MIT',
     });
     if (p.isCancel(license)) {
         p.cancel('Cancelled.');
@@ -81,9 +81,13 @@ export async function promptUser() {
         message: 'What do you want to include in your extension?',
         options: [
             { value: 'theme', label: 'Theme', hint: 'Color scheme for the editor' },
-            { value: 'language', label: 'Language', hint: 'Syntax highlighting, indentation, etc.' }
+            {
+                value: 'language',
+                label: 'Language',
+                hint: 'Syntax highlighting, indentation, etc.',
+            },
         ],
-        required: true
+        required: true,
     });
     if (p.isCancel(extensionTypes)) {
         p.cancel('Cancelled.');
@@ -96,14 +100,14 @@ export async function promptUser() {
         author: String(author),
         repository: repositoryValue,
         license: license,
-        types: extensionTypes
+        types: extensionTypes,
     };
     return options;
 }
 export async function promptThemeDetails() {
     const themeName = await p.text({
         message: 'Theme name:',
-        placeholder: 'My Theme'
+        placeholder: 'My Theme',
     });
     if (p.isCancel(themeName)) {
         p.cancel('Cancelled.');
@@ -114,9 +118,9 @@ export async function promptThemeDetails() {
         options: [
             { value: 'dark', label: 'Dark' },
             { value: 'light', label: 'Light' },
-            { value: 'both', label: 'Both (Dark & Light)' }
+            { value: 'both', label: 'Both (Dark & Light)' },
         ],
-        initialValue: 'dark'
+        initialValue: 'dark',
     });
     if (p.isCancel(appearance)) {
         p.cancel('Cancelled.');
@@ -124,13 +128,13 @@ export async function promptThemeDetails() {
     }
     return {
         themeName: String(themeName),
-        appearance: appearance
+        appearance: appearance,
     };
 }
 export async function promptLanguageDetails() {
     const languageName = await p.text({
         message: 'Language name:',
-        placeholder: 'My Language'
+        placeholder: 'My Language',
     });
     if (p.isCancel(languageName)) {
         p.cancel('Cancelled.');
@@ -138,7 +142,7 @@ export async function promptLanguageDetails() {
     }
     const result = {
         languageName: String(languageName),
-        languageId: String(languageName).toLowerCase().replace(/\s+/g, '-')
+        languageId: String(languageName).toLowerCase().replace(/\s+/g, '-'),
     };
     return result;
 }

package/dist/snippet.d.ts

@@ -0,0 +1 @@
+export declare function addLsp(callerDir: string): Promise<void>;

package/dist/snippet.js

@@ -0,0 +1,168 @@
+import path from 'path';
+import { fileURLToPath } from 'url';
+import * as p from '@clack/prompts';
+import ejs from 'ejs';
+import fs from 'fs-extra';
+import color from 'picocolors';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const isDev = __dirname.includes('/src/');
+const PROJECT_ROOT = isDev ? path.join(__dirname, '..') : __dirname;
+const TEMPLATE_DIR = path.join(PROJECT_ROOT, 'templates');
+async function renderTemplate(templatePath, data) {
+    const template = await fs.readFile(templatePath, 'utf-8');
+    return ejs.render(template, data);
+}
+function tomlGet(content, key) {
+    const match = content.match(new RegExp(`^${key}\\s*=\\s*"([^"]*)"`, 'm'));
+    return match?.[1];
+}
+function toPascalCase(str) {
+    return str
+        .replace(/[-_\s]+(.)/g, (_, c) => c.toUpperCase())
+        .replace(/^(.)/, (c) => c.toUpperCase());
+}
+function detectLanguages(callerDir) {
+    try {
+        const langsDir = path.join(callerDir, 'languages');
+        if (!fs.pathExistsSync(langsDir))
+            return [];
+        return fs
+            .readdirSync(langsDir, { withFileTypes: true })
+            .filter(d => d.isDirectory())
+            .map(d => d.name);
+    }
+    catch {
+        return [];
+    }
+}
+export async function addLsp(callerDir) {
+    p.intro(`${color.bgBlue(color.bold(' zedx snippet add lsp '))} ${color.blue('Wiring up a language server…')}`);
+    const tomlPath = path.join(callerDir, 'extension.toml');
+    if (!(await fs.pathExists(tomlPath))) {
+        p.log.error(color.red('No extension.toml found. Run zedx from an extension directory.'));
+        process.exit(1);
+    }
+    const tomlContent = await fs.readFile(tomlPath, 'utf-8');
+    const extensionId = tomlGet(tomlContent, 'id') ?? 'my-extension';
+    const extensionName = tomlGet(tomlContent, 'name') ?? extensionId;
+    // --- LSP server name ---
+    const lspNameDefault = `${extensionName} LSP`;
+    const lspName = await p.text({
+        message: 'Language server display name:',
+        placeholder: lspNameDefault,
+    });
+    if (p.isCancel(lspName)) {
+        p.cancel('Cancelled.');
+        process.exit(0);
+    }
+    const lspNameValue = String(lspName || lspNameDefault);
+    // Derive a TOML-safe ID from the display name
+    const lspId = lspNameValue
+        .toLowerCase()
+        .replace(/\s+/g, '-')
+        .replace(/[^a-z0-9-]/g, '');
+    // --- Check for duplicate ---
+    if (new RegExp(`^\\[language_servers\\.${lspId}\\]`, 'm').test(tomlContent)) {
+        p.log.error(color.red(`[language_servers.${lspId}] already exists in extension.toml.`));
+        process.exit(1);
+    }
+    // --- Language association ---
+    const detectedLanguages = detectLanguages(callerDir);
+    let languageName;
+    if (detectedLanguages.length > 0) {
+        const choice = await p.select({
+            message: 'Which language does this LSP serve?',
+            options: [
+                ...detectedLanguages.map(l => ({
+                    value: l,
+                    label: toPascalCase(l),
+                })),
+                { value: '__custom__', label: 'Enter manually' },
+            ],
+        });
+        if (p.isCancel(choice)) {
+            p.cancel('Cancelled.');
+            process.exit(0);
+        }
+        if (choice === '__custom__') {
+            const custom = await p.text({
+                message: 'Language name (must match name in config.toml):',
+                placeholder: extensionName,
+            });
+            if (p.isCancel(custom)) {
+                p.cancel('Cancelled.');
+                process.exit(0);
+            }
+            languageName = String(custom || extensionName);
+        }
+        else {
+            languageName = toPascalCase(String(choice));
+        }
+    }
+    else {
+        const custom = await p.text({
+            message: 'Language name (must match name in config.toml):',
+            placeholder: extensionName,
+        });
+        if (p.isCancel(custom)) {
+            p.cancel('Cancelled.');
+            process.exit(0);
+        }
+        languageName = String(custom || extensionName);
+    }
+    // --- LSP binary command ---
+    const lspCommand = await p.text({
+        message: 'LSP binary command (the executable name or path):',
+        placeholder: `${lspId}-server`,
+    });
+    if (p.isCancel(lspCommand)) {
+        p.cancel('Cancelled.');
+        process.exit(0);
+    }
+    const lspCommandValue = String(lspCommand || `${lspId}-server`);
+    // --- Append [language_servers.*] block to extension.toml ---
+    const lspTomlBlock = `\n[language_servers.${lspId}]\n` +
+        `name = "${lspNameValue}"\n` +
+        `languages = ["${languageName}"]\n`;
+    await fs.appendFile(tomlPath, lspTomlBlock);
+    p.log.success(`Updated ${color.cyan('extension.toml')} with [language_servers.${lspId}]`);
+    // --- Add lib.path to extension.toml if not present ---
+    const updatedToml = await fs.readFile(tomlPath, 'utf-8');
+    if (!/^lib\s*=/m.test(updatedToml)) {
+        await fs.appendFile(tomlPath, `\nlib.path = "extension.wasm"\n`);
+        p.log.success(`Updated ${color.cyan('extension.toml')} with lib.path`);
+    }
+    const structName = toPascalCase(extensionId).replace(/-/g, '');
+    // --- Generate Cargo.toml if not present ---
+    const cargoPath = path.join(callerDir, 'Cargo.toml');
+    if (!(await fs.pathExists(cargoPath))) {
+        const cargoToml = await renderTemplate(path.join(TEMPLATE_DIR, 'lsp/Cargo.toml.ejs'), {
+            extensionId,
+        });
+        await fs.writeFile(cargoPath, cargoToml);
+        p.log.success(`Created ${color.cyan('Cargo.toml')}`);
+    }
+    else {
+        p.log.warn(`${color.yellow('Cargo.toml already exists')} — skipped`);
+    }
+    // --- Generate src/lib.rs if not present ---
+    const srcDir = path.join(callerDir, 'src');
+    const libRsPath = path.join(srcDir, 'lib.rs');
+    if (!(await fs.pathExists(libRsPath))) {
+        await fs.ensureDir(srcDir);
+        const libRs = await renderTemplate(path.join(TEMPLATE_DIR, 'lsp/lib.rs.ejs'), {
+            structName,
+            lspCommand: lspCommandValue,
+        });
+        await fs.writeFile(libRsPath, libRs);
+        p.log.success(`Created ${color.cyan('src/lib.rs')}`);
+    }
+    else {
+        p.log.warn(`${color.yellow('src/lib.rs already exists')} — skipped`);
+    }
+    p.outro(`${color.green('✓')} LSP snippet added.\n\n` +
+        `  ${color.dim('1.')} Edit ${color.cyan('src/lib.rs')} — implement ${color.white('language_server_command')}\n` +
+        `  ${color.dim('2.')} Edit ${color.cyan('Cargo.toml')} — pin ${color.white('zed_extension_api')} to latest version\n` +
+        `  ${color.dim('3.')} ${color.dim('Docs:')} ${color.underline(color.blue('https://zed.dev/docs/extensions/languages#language-servers'))}`);
+}

package/dist/sync.js

@@ -1,7 +1,7 @@
 import os from 'os';
 import path from 'path';
-import fs from 'fs-extra';
 import * as p from '@clack/prompts';
+import fs from 'fs-extra';
 import color from 'picocolors';
 import simpleGit from 'simple-git';
 import { resolveZedPaths } from './zed-paths.js';
@@ -16,7 +16,9 @@ async function readSyncConfig() {
 async function requireSyncConfig() {
     const config = await readSyncConfig();
     if (!config) {
-        p.log.error(color.red('No sync config found. Run ') + color.cyan('zedx sync init') + color.red(' first.'));
+        p.log.error(color.red('No sync config found. Run ') +
+            color.cyan('zedx sync init') +
+            color.red(' first.'));
         process.exit(1);
     }
     return config;
@@ -35,6 +37,26 @@ async function withTempDir(fn) {
         await fs.remove(tmp);
     }
 }
+// Prepare settings.json for pushing to the repo by stripping auto_install_extensions.
+// That field is derived from extensions/index.json on pull, so storing it in the
+// remote would create stale/conflicting data across machines.
+async function prepareSettingsForPush(localSettingsPath, repoSettingsPath) {
+    const raw = await fs.readFile(localSettingsPath, 'utf-8');
+    const stripped = raw.replace(/\/\/[^\n]*/g, '');
+    let settingsObj = {};
+    try {
+        settingsObj = JSON.parse(stripped);
+    }
+    catch {
+        // If we can't parse it (e.g. complex comments), push as-is
+        await fs.ensureDir(path.dirname(repoSettingsPath));
+        await fs.copy(localSettingsPath, repoSettingsPath, { overwrite: true });
+        return;
+    }
+    delete settingsObj['auto_install_extensions'];
+    await fs.ensureDir(path.dirname(repoSettingsPath));
+    await fs.writeFile(repoSettingsPath, JSON.stringify(settingsObj, null, 4), 'utf-8');
+}
 // Extension merge helper
 async function applyRemoteSettings(repoSettings, repoExtensions, localSettingsPath, silent = false) {
     // Backup existing settings
@@ -48,7 +70,7 @@ async function applyRemoteSettings(repoSettings, repoExtensions, localSettingsPa
     if (await fs.pathExists(repoExtensions)) {
         try {
             const indexJson = (await fs.readJson(repoExtensions));
-            const extensionIds = Object.keys(indexJson.extensions ?? {}).filter((id) => !indexJson.extensions[id]?.dev);
+            const extensionIds = Object.keys(indexJson.extensions ?? {}).filter(id => !indexJson.extensions[id]?.dev);
             if (extensionIds.length > 0) {
                 const stripped = settingsJson.replace(/\/\/[^\n]*/g, '');
                 let settingsObj = {};
@@ -59,12 +81,23 @@ async function applyRemoteSettings(repoSettings, repoExtensions, localSettingsPa
                     if (!silent)
                         p.log.warn(color.yellow('Could not parse settings.json — skipping extension merge.'));
                 }
-                const autoInstall = {};
+                // Preserve any existing entries (e.g. false entries for "never install"),
+                // then add true for every extension recorded in index.json.
+                const existing = typeof settingsObj['auto_install_extensions'] === 'object' &&
+                    settingsObj['auto_install_extensions'] !== null
+                    ? settingsObj['auto_install_extensions']
+                    : {};
+                const autoInstall = { ...existing };
                 for (const id of extensionIds) {
-                    autoInstall[id] = true;
+                    // Only set to true if there is no explicit user preference already
+                    if (!(id in autoInstall)) {
+                        autoInstall[id] = true;
+                    }
                 }
                 settingsObj['auto_install_extensions'] = autoInstall;
                 settingsJson = JSON.stringify(settingsObj, null, 4);
+                if (!silent)
+                    p.log.info(`Injected ${color.cyan(String(extensionIds.length))} extension(s) into ${color.dim('auto_install_extensions')}`);
             }
         }
         catch {
@@ -77,7 +110,7 @@ async function applyRemoteSettings(repoSettings, repoExtensions, localSettingsPa
 }
 // zedx sync status
 export async function syncStatus() {
-    p.intro(color.bold('zedx sync status'));
+    p.intro(`${color.bgBlue(color.bold(' zedx sync status '))} ${color.blue('Checking sync state…')}`);
     const config = await requireSyncConfig();
     const zedPaths = resolveZedPaths();
     p.log.info(`Repo:   ${color.dim(config.syncRepo)} ${color.dim(`(${config.branch})`)}`);
@@ -104,13 +137,13 @@ export async function syncStatus() {
             {
                 repoPath: path.join(tmp, 'settings.json'),
                 localPath: zedPaths.settings,
-                label: 'settings.json'
+                label: 'settings.json',
             },
             {
                 repoPath: path.join(tmp, 'extensions', 'index.json'),
                 localPath: zedPaths.extensions,
-                label: 'extensions/index.json'
-            }
+                label: 'extensions/index.json',
+            },
         ];
         for (const file of files) {
             const localExists = await fs.pathExists(file.localPath);
@@ -153,17 +186,17 @@ export async function syncStatus() {
 }
 // zedx sync init
 export async function syncInit() {
-    p.intro(color.bold('zedx sync init'));
+    p.intro(`${color.bgBlue(color.bold(' zedx sync init '))} ${color.blue('Linking a git repo as the sync target…')}`);
     const repo = await p.text({
         message: 'GitHub repo URL (SSH or HTTPS)',
         placeholder: 'https://github.com/you/zed-config.git',
-        validate: (v) => {
+        validate: v => {
             if (!v.trim())
                 return 'Repo URL is required';
             if (!v.startsWith('https://') && !v.startsWith('git@')) {
                 return 'Must be a valid HTTPS or SSH git URL';
             }
-        }
+        },
     });
     if (p.isCancel(repo)) {
         p.cancel('Cancelled.');
@@ -172,7 +205,7 @@ export async function syncInit() {
     const branch = await p.text({
         message: 'Branch name',
         placeholder: 'main',
-        defaultValue: 'main'
+        defaultValue: 'main',
     });
     if (p.isCancel(branch)) {
         p.cancel('Cancelled.');
@@ -190,7 +223,7 @@ export async function syncInit() {
     }
     const config = {
         syncRepo: repo.trim(),
-        branch: (branch || 'main').trim()
+        branch: (branch || 'main').trim(),
     };
     await writeSyncConfig(config);
     p.outro(`${color.green('✓')} Sync config saved to ${color.cyan(ZEDX_CONFIG_PATH)}\n\n` +
@@ -215,17 +248,17 @@ export async function runSync(opts = {}) {
         success: (msg) => {
             if (!silent)
                 p.log.success(msg);
-        }
+        },
     };
     if (!silent)
-        p.intro(color.bold('zedx sync'));
+        p.intro(`${color.bgBlue(color.bold(' zedx sync '))} ${color.blue('Syncing Zed settings and extensions…')}`);
     const config = await requireSyncConfig();
     const zedPaths = resolveZedPaths();
     // Spinner shim: in silent mode just log to stderr so daemons can capture it
     const spinner = silent
         ? {
             start: (m) => console.error(`[zedx] ${m}`),
-            stop: (m) => console.error(`[zedx] ${m}`)
+            stop: (m) => console.error(`[zedx] ${m}`),
         }
         : p.spinner();
     await withTempDir(async (tmp) => {
@@ -249,13 +282,13 @@ export async function runSync(opts = {}) {
             {
                 repoPath: path.join(tmp, 'settings.json'),
                 localPath: zedPaths.settings,
-                label: 'settings.json'
+                label: 'settings.json',
             },
             {
                 repoPath: path.join(tmp, 'extensions', 'index.json'),
                 localPath: zedPaths.extensions,
-                label: 'extensions/index.json'
-            }
+                label: 'extensions/index.json',
+            },
         ];
         let anyChanges = false;
         for (const file of files) {
@@ -269,8 +302,13 @@ export async function runSync(opts = {}) {
             // Remote doesn't have it yet — push local
             if (localExists && !remoteFileExists) {
                 log.info(`${file.label}: ${color.green('pushing')} (not in remote yet)`);
-                await fs.ensureDir(path.dirname(file.repoPath));
-                await fs.copy(file.localPath, file.repoPath, { overwrite: true });
+                if (file.label === 'settings.json') {
+                    await prepareSettingsForPush(file.localPath, file.repoPath);
+                }
+                else {
+                    await fs.ensureDir(path.dirname(file.repoPath));
+                    await fs.copy(file.localPath, file.repoPath, { overwrite: true });
+                }
                 anyChanges = true;
                 continue;
             }
@@ -295,14 +333,21 @@ export async function runSync(opts = {}) {
             }
             // Detect which side changed since last sync via mtime
             const localMtime = (await fs.stat(file.localPath)).mtime;
-            const remoteMtime = remoteFileExists ? (await fs.stat(file.repoPath)).mtime : new Date(0);
+            const remoteMtime = remoteFileExists
+                ? (await fs.stat(file.repoPath)).mtime
+                : new Date(0);
             const localChanged = !lastSync || localMtime > lastSync;
             const remoteChanged = !lastSync || remoteMtime > lastSync;
             if (localChanged && !remoteChanged) {
                 // Only local changed → push
                 log.info(`${file.label}: ${color.green('pushing')} (local is newer)`);
-                await fs.ensureDir(path.dirname(file.repoPath));
-                await fs.copy(file.localPath, file.repoPath, { overwrite: true });
+                if (file.label === 'settings.json') {
+                    await prepareSettingsForPush(file.localPath, file.repoPath);
+                }
+                else {
+                    await fs.ensureDir(path.dirname(file.repoPath));
+                    await fs.copy(file.localPath, file.repoPath, { overwrite: true });
+                }
                 anyChanges = true;
             }
             else if (remoteChanged && !localChanged) {
@@ -321,26 +366,31 @@ export async function runSync(opts = {}) {
                 if (silent) {
                     // Daemon can't prompt — local wins, will be pushed
                     log.warn(`${file.label}: conflict detected in unattended mode — keeping local.`);
-                    await fs.ensureDir(path.dirname(file.repoPath));
-                    await fs.copy(file.localPath, file.repoPath, { overwrite: true });
+                    if (file.label === 'settings.json') {
+                        await prepareSettingsForPush(file.localPath, file.repoPath);
+                    }
+                    else {
+                        await fs.ensureDir(path.dirname(file.repoPath));
+                        await fs.copy(file.localPath, file.repoPath, { overwrite: true });
+                    }
                     anyChanges = true;
                 }
                 else {
-                    p.log.warn(color.yellow(`${file.label}: both local and remote changed.`));
+                    p.log.warn(color.yellow(`conflict between local and remote ${file.label}`));
                     const choice = await p.select({
                         message: `Which version of ${color.bold(file.label)} should win?`,
                         options: [
                             {
                                 value: 'local',
                                 label: 'Keep local',
-                                hint: `modified ${localMtime.toLocaleString()}`
+                                hint: `modified ${localMtime.toLocaleString()}`,
                             },
                             {
                                 value: 'remote',
                                 label: 'Use remote',
-                                hint: `modified ${remoteMtime.toLocaleString()}`
-                            }
-                        ]
+                                hint: `modified ${remoteMtime.toLocaleString()}`,
+                            },
+                        ],
                     });
                     if (p.isCancel(choice)) {
                         p.cancel('Cancelled.');
@@ -348,8 +398,13 @@ export async function runSync(opts = {}) {
                     }
                     if (choice === 'local') {
                         p.log.info(`${file.label}: ${color.green('keeping local, will push')}`);
-                        await fs.ensureDir(path.dirname(file.repoPath));
-                        await fs.copy(file.localPath, file.repoPath, { overwrite: true });
+                        if (file.label === 'settings.json') {
+                            await prepareSettingsForPush(file.localPath, file.repoPath);
+                        }
+                        else {
+                            await fs.ensureDir(path.dirname(file.repoPath));
+                            await fs.copy(file.localPath, file.repoPath, { overwrite: true });
+                        }
                         anyChanges = true;
                     }
                     else {

package/dist/templates/base/extension.toml.ejs

@@ -2,21 +2,23 @@ id = "<%= id %>"
 name = "<%= name %>"
 version = "0.0.1"
 schema_version = 1
-authors = ["<%- author %>"]
+authors = ["<%- author %>"] # TODO(edit-me): replace with your name and email
 description = "<%= description %>"
-repository = "<%= repository %>"
+repository = "<%= repository %>" # TODO(edit-me): update to your actual repository URL
 
 <% if (types.includes('language') && grammarRepo) { %>
 [grammars.<%= languageId %>]
 repository = "<%= grammarRepo %>"
 rev = "<%= grammarRev || 'main' %>"
 <% } else if (types.includes('language')) { %>
+# TODO(edit-me): uncomment and fill in the grammar block once you have a Tree-sitter grammar repo
 # [grammars.<%= languageId %>]
 # repository = "https://github.com/user/tree-sitter-<%= languageId %>"
 # rev = "main"
 <% } %>
 
 <% if (types.includes('language')) { %>
+# TODO(edit-me): uncomment and fill in the LSP block if your language has a language server
 # [language_servers.my-lsp]
 # name = "My Language LSP"
 # languages = ["<%= languageName %>"]

package/dist/templates/language/config.toml.ejs

@@ -4,10 +4,12 @@ name = "<%= languageName %>"
 # grammar (required): The name of a Tree-sitter grammar (must match grammar registration in extension.toml)
 grammar = "<%= languageId %>"
 
-# path_suffixes: Array of file suffixes associated with this language (e.g., ["myl", "my"])
+# TODO(edit-me): uncomment and set the file extensions for your language (e.g., ["myl", "my"])
+# path_suffixes: Array of file suffixes associated with this language
 # Unlike file_types in settings, this does not support glob patterns
 # path_suffixes = []
 
+# TODO(edit-me): uncomment and set the comment syntax for your language (e.g., ["// ", "# "])
 # line_comments: Array of strings used to identify line comments
 # Used for editor::ToggleComments keybind (cmd-/ or ctrl-/)
 # line_comments = ["// ", "# "]

package/dist/templates/language/highlights.scm

@@ -27,6 +27,7 @@
 ; Learn more about Tree-sitter queries:
 ;   https://tree-sitter.github.io/tree-sitter/using-parsers/queries
 
+; TODO(edit-me): replace these with the actual node type names from your Tree-sitter grammar
 (string) @string
 (number) @number
 (comment) @comment

package/dist/templates/lsp/Cargo.toml.ejs

@@ -0,0 +1,12 @@
+[package]
+name = "<%= extensionId %>"
+version = "0.0.1"
+edition = "2024"
+
+[lib]
+crate-type = ["cdylib"]
+
+[dependencies]
+# TODO(edit-me): pin to the latest version compatible with your target Zed version
+# See: https://crates.io/crates/zed_extension_api
+zed_extension_api = "0.4"

package/dist/templates/lsp/lib.rs.ejs

@@ -0,0 +1,30 @@
+use zed_extension_api::{self as zed, LanguageServerId, Result};
+
+struct <%= structName %> {
+    // TODO(edit-me): add any cached state here (e.g. cached binary path)
+}
+
+impl zed::Extension for <%= structName %> {
+    fn new() -> Self {
+        Self {}
+    }
+
+    fn language_server_command(
+        &mut self,
+        _language_server_id: &LanguageServerId,
+        _worktree: &zed::Worktree,
+    ) -> Result<zed::Command> {
+        // TODO(edit-me): resolve the path to the LSP binary.
+        // Common patterns:
+        //   - zed::Command { command: worktree.which("<%= lspCommand %>")?.ok_or("...")?, ... }
+        //   - download the binary via zed::download_file and cache the path
+        // See: https://docs.rs/zed_extension_api
+        Ok(zed::Command {
+            command: "<%= lspCommand %>".to_string(), // TODO(edit-me): replace with actual binary path
+            args: vec![],                              // TODO(edit-me): add required args
+            env: vec![],
+        })
+    }
+}
+
+zed::register_extension!(<%= structName %>);