zedx 0.7.0 → 0.8.0

package/dist/index.js

@@ -8,7 +8,9 @@ import { addTheme, addLanguage } from './add.js';
 import { runCheck } from './check.js';
 import { syncInstall, syncUninstall } from './daemon.js';
 import { generateExtension } from './generator.js';
+import { installDevExtension } from './install.js';
 import { promptUser, promptThemeDetails, promptLanguageDetails } from './prompts.js';
+import { addLsp } from './snippet.js';
 import { syncInit, runSync, syncStatus } from './sync.js';
 function bumpVersion(version, type) {
     const [major, minor, patch] = version.split('.').map(Number);
@@ -43,9 +45,67 @@ async function bumpExtensionVersion(type) {
     await fs.writeFile(tomlPath, newContent);
     p.log.success(color.green(`Bumped version from ${currentVersion} to ${newVersion}`));
 }
+function printWelcome() {
+    const ascii = String.raw `
+░        ░░        ░░       ░░░  ░░░░  ░
+▒▒▒▒▒▒  ▒▒▒  ▒▒▒▒▒▒▒▒  ▒▒▒▒  ▒▒▒  ▒▒  ▒▒
+▓▓▓▓  ▓▓▓▓▓      ▓▓▓▓  ▓▓▓▓  ▓▓▓▓    ▓▓▓
+██  ███████  ████████  ████  ███  ██  ██
+█        ██        ██       ███  ████  █
+                                        
+    `.trim();
+    console.log('\n' + color.cyan(color.bold(ascii)) + '\n');
+    console.log(color.bold('  The CLI toolkit for Zed Editor') + '\n');
+    const commands = [
+        ['zedx create', 'Scaffold a new Zed extension'],
+        ['zedx add theme <name>', 'Add a theme to an existing extension'],
+        ['zedx add language <id>', 'Add a language to an existing extension'],
+        ['zedx snippet add lsp', 'Wire up a language server into the extension'],
+        ['zedx check', 'Validate your extension config'],
+        ['zedx install', 'Install as a Zed dev extension'],
+        ['zedx version <major|minor|patch>', 'Bump extension version'],
+        ['zedx sync', 'Sync Zed settings via a git repo'],
+        ['zedx sync init', 'Link a git repo as the sync target'],
+        ['zedx sync status', 'Show sync state between local and remote'],
+        ['zedx sync install', 'Install the OS daemon for auto-sync'],
+        ['zedx sync uninstall', 'Remove the auto-sync daemon'],
+    ];
+    console.log(color.dim('  Commands:\n'));
+    for (const [cmd, desc] of commands) {
+        console.log(`  ${color.cyan(cmd.padEnd(38))}${color.dim(desc)}`);
+    }
+    console.log(`\n  ${color.dim('Docs:')} ${color.underline(color.blue('https://zed.dev/docs/extensions'))}\n`);
+}
+async function runCreate() {
+    const options = await promptUser();
+    if (options.types.includes('theme')) {
+        const themeDetails = await promptThemeDetails();
+        Object.assign(options, themeDetails);
+    }
+    if (options.types.includes('language')) {
+        const languageDetails = await promptLanguageDetails();
+        Object.assign(options, languageDetails);
+    }
+    const targetDir = path.join(getCallerDir(), options.id);
+    await generateExtension(options, targetDir);
+    p.outro(`${color.green('✓')} ${color.bold('Extension created successfully!')}\n` +
+        `${color.gray('─'.repeat(40))}\n` +
+        `${color.dim('Location:')} ${color.cyan(targetDir)}`);
+    p.outro(`${color.yellow('⚡')} ${color.bold('Next steps')}\n\n` +
+        `  ${color.gray('1.')} Open Zed\n` +
+        `  ${color.gray('2.')} ${color.white('Extensions > Install Dev Extension')}\n` +
+        `  ${color.gray('3.')} Select ${color.cyan(options.id)} folder\n\n` +
+        `${color.dim('Learn more:')} ${color.underline(color.blue('https://zed.dev/docs/extensions/developing-extensions'))}`);
+}
 async function main() {
     const program = new Command();
-    program.name('zedx').description('Boilerplate generator for Zed Editor extensions.');
+    program.name('zedx').description('The CLI toolkit for Zed Editor.').helpOption(false);
+    program
+        .command('create')
+        .description('Scaffold a new Zed extension')
+        .action(async () => {
+        await runCreate();
+    });
     program
         .command('version')
         .description('Bump the version of the extension')
@@ -63,6 +123,12 @@ async function main() {
         .action(async () => {
         await runCheck(getCallerDir());
     });
+    program
+        .command('install')
+        .description('Install the current extension as a Zed dev extension')
+        .action(async () => {
+        await installDevExtension(getCallerDir());
+    });
     const addCmd = program
         .command('add')
         .description('Add a theme or language to an existing extension');
@@ -78,6 +144,15 @@ async function main() {
         .action(async (id) => {
         await addLanguage(getCallerDir(), id);
     });
+    const snippetCmd = program
+        .command('snippet')
+        .description('Inject a code snippet into an existing extension');
+    snippetCmd
+        .command('add lsp')
+        .description('Wire up a language server (Rust + WASM) into the extension')
+        .action(async () => {
+        await addLsp(getCallerDir());
+    });
     const syncCmd = program
         .command('sync')
         .description('Sync Zed settings and extensions via a GitHub repo')
@@ -109,25 +184,7 @@ async function main() {
         await syncUninstall();
     });
     if (process.argv.length <= 2) {
-        const options = await promptUser();
-        if (options.types.includes('theme')) {
-            const themeDetails = await promptThemeDetails();
-            Object.assign(options, themeDetails);
-        }
-        if (options.types.includes('language')) {
-            const languageDetails = await promptLanguageDetails();
-            Object.assign(options, languageDetails);
-        }
-        const targetDir = path.join(getCallerDir(), options.id);
-        await generateExtension(options, targetDir);
-        p.outro(`${color.green('✓')} ${color.bold('Extension created successfully!')}\n` +
-            `${color.gray('─'.repeat(40))}\n` +
-            `${color.dim('Location:')} ${color.cyan(targetDir)}`);
-        p.outro(`${color.yellow('⚡')} ${color.bold('Next steps')}\n\n` +
-            `  ${color.gray('1.')} Open Zed\n` +
-            `  ${color.gray('2.')} ${color.white('Extensions > Install Dev Extension')}\n` +
-            `  ${color.gray('3.')} Select ${color.cyan(options.id)} folder\n\n` +
-            `${color.dim('Learn more:')} ${color.underline(color.blue('https://zed.dev/docs/extensions/developing-extensions'))}`);
+        printWelcome();
         return;
     }
     program.parse(process.argv);

package/dist/install.d.ts

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

package/dist/install.js

@@ -0,0 +1,188 @@
+import os from 'os';
+import path from 'path';
+import * as p from '@clack/prompts';
+import fs from 'fs-extra';
+import color from 'picocolors';
+// TOML helpers (regex-based — no parser dependency needed for these fields)
+function tomlGetString(content, key) {
+    const match = content.match(new RegExp(`^${key}\\s*=\\s*"([^"]*)"`, 'm'));
+    return match?.[1];
+}
+function tomlGetNumber(content, key) {
+    const match = content.match(new RegExp(`^${key}\\s*=\\s*(\\d+)`, 'm'));
+    return match ? Number(match[1]) : undefined;
+}
+function tomlGetAuthors(content) {
+    const match = content.match(/^authors\s*=\s*\[([^\]]*)\]/m);
+    if (!match)
+        return [];
+    return [...match[1].matchAll(/"([^"]*)"/g)].map(m => m[1]);
+}
+// Filesystem helpers
+function resolveZedExtensionsDir() {
+    const home = os.homedir();
+    const platform = process.platform;
+    if (platform === 'darwin') {
+        return path.join(home, 'Library', 'Application Support', 'Zed', 'extensions');
+    }
+    if (platform === 'linux') {
+        const xdgData = process.env.FLATPAK_XDG_DATA_HOME ||
+            process.env.XDG_DATA_HOME ||
+            path.join(home, '.local', 'share');
+        return path.join(xdgData, 'zed', 'extensions');
+    }
+    if (platform === 'win32') {
+        const localAppData = process.env.LOCALAPPDATA || path.join(home, 'AppData', 'Local');
+        return path.join(localAppData, 'Zed', 'extensions');
+    }
+    throw new Error(`Unsupported platform: ${platform}`);
+}
+function listSubdirs(dir) {
+    try {
+        return fs
+            .readdirSync(dir, { withFileTypes: true })
+            .filter(d => d.isDirectory())
+            .map(d => d.name);
+    }
+    catch {
+        return [];
+    }
+}
+function buildManifest(extensionDir, toml) {
+    const id = tomlGetString(toml, 'id') ?? 'unknown';
+    const name = tomlGetString(toml, 'name') ?? id;
+    const version = tomlGetString(toml, 'version') ?? '0.0.1';
+    const schemaVersion = tomlGetNumber(toml, 'schema_version') ?? 1;
+    const description = tomlGetString(toml, 'description') ?? '';
+    const repository = tomlGetString(toml, 'repository') ?? '';
+    const authors = tomlGetAuthors(toml);
+    // Detect themes
+    const themesDir = path.join(extensionDir, 'themes');
+    const themes = fs.pathExistsSync(themesDir)
+        ? fs
+            .readdirSync(themesDir)
+            .filter(f => f.endsWith('.json'))
+            .map(f => `themes/${f}`)
+        : [];
+    // Detect languages
+    const langsDir = path.join(extensionDir, 'languages');
+    const languages = fs.pathExistsSync(langsDir)
+        ? listSubdirs(langsDir).map(d => `languages/${d}`)
+        : [];
+    // Detect grammars from extension.toml  [grammars.<id>] blocks
+    const grammars = {};
+    const grammarMatches = toml.matchAll(/^\[grammars\.([^\]]+)\]\s*\nrepository\s*=\s*"([^"]*)"\s*\nrev\s*=\s*"([^"]*)"/gm);
+    for (const m of grammarMatches) {
+        grammars[m[1]] = { repository: m[2], rev: m[3], path: null };
+    }
+    // Detect language_servers from extension.toml  [language_servers.<id>] blocks
+    const languageServers = {};
+    const lsMatches = toml.matchAll(/^\[language_servers\.([^\]]+)\]\s*\nname\s*=\s*"([^"]*)"\s*\nlanguages\s*=\s*\[([^\]]*)\]/gm);
+    for (const m of lsMatches) {
+        const langs = [...m[3].matchAll(/"([^"]*)"/g)].map(x => x[1]);
+        languageServers[m[1]] = {
+            language: langs[0] ?? '',
+            languages: langs.slice(1),
+            language_ids: {},
+            code_action_kinds: null,
+        };
+    }
+    // Detect whether Rust lib is present
+    const hasLib = fs.pathExistsSync(path.join(extensionDir, 'Cargo.toml'));
+    return {
+        id,
+        name,
+        version,
+        schema_version: schemaVersion,
+        description,
+        repository,
+        authors,
+        lib: { kind: hasLib ? 'Rust' : null, version: null },
+        themes,
+        icon_themes: [],
+        languages,
+        grammars,
+        language_servers: languageServers,
+        context_servers: {},
+        agent_servers: {},
+        slash_commands: {},
+        snippets: null,
+        capabilities: [],
+    };
+}
+// Main install function
+export async function installDevExtension(callerDir) {
+    p.intro(`${color.bgBlue(color.bold(' zedx install '))} ${color.blue('Installing as a Zed dev extension…')}`);
+    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 toml = await fs.readFile(tomlPath, 'utf-8');
+    const extensionId = tomlGetString(toml, 'id');
+    if (!extensionId) {
+        p.log.error(color.red('Could not read extension id from extension.toml.'));
+        process.exit(1);
+    }
+    let extensionsDir;
+    try {
+        extensionsDir = resolveZedExtensionsDir();
+    }
+    catch (err) {
+        p.log.error(color.red(String(err)));
+        process.exit(1);
+    }
+    const installedDir = path.join(extensionsDir, 'installed');
+    const indexPath = path.join(extensionsDir, 'index.json');
+    const symlinkPath = path.join(installedDir, extensionId);
+    await fs.ensureDir(installedDir);
+    // --- Handle existing symlink / directory ---
+    if (await fs.pathExists(symlinkPath)) {
+        const stat = await fs.lstat(symlinkPath);
+        if (stat.isSymbolicLink()) {
+            const existing = await fs.readlink(symlinkPath);
+            if (existing === callerDir) {
+                p.log.warn(`${color.yellow(`${extensionId}`)} is already installed and points to this directory.`);
+            }
+            else {
+                const overwrite = await p.confirm({
+                    message: `${extensionId} is already installed (→ ${existing}). Replace it?`,
+                    initialValue: true,
+                });
+                if (p.isCancel(overwrite) || !overwrite) {
+                    p.cancel('Cancelled.');
+                    process.exit(0);
+                }
+                await fs.remove(symlinkPath);
+                await fs.symlink(callerDir, symlinkPath);
+                p.log.success(`Replaced symlink ${color.cyan(`installed/${extensionId}`)} → ${color.dim(callerDir)}`);
+            }
+        }
+        else {
+            p.log.error(color.red(`${symlinkPath} exists and is not a symlink. Remove it manually first.`));
+            process.exit(1);
+        }
+    }
+    else {
+        await fs.symlink(callerDir, symlinkPath);
+        p.log.success(`Created symlink ${color.cyan(`installed/${extensionId}`)} → ${color.dim(callerDir)}`);
+    }
+    // --- Upsert index.json ---
+    let index = { extensions: {} };
+    if (await fs.pathExists(indexPath)) {
+        try {
+            index = await fs.readJson(indexPath);
+        }
+        catch {
+            // malformed — start fresh
+        }
+    }
+    const manifest = buildManifest(callerDir, toml);
+    index.extensions[extensionId] = { manifest, dev: true };
+    await fs.writeJson(indexPath, index, { spaces: 2 });
+    p.log.success(`Updated ${color.cyan('index.json')}`);
+    p.outro(`${color.green('✓')} ${color.bold(`${manifest.name} v${manifest.version}`)} installed as a dev extension.\n\n` +
+        `  ${color.dim('Reload Zed to pick up the changes:')}\n` +
+        `  ${color.white('Extensions')} ${color.dim('→')} ${color.white('Reload Extensions')}  ${color.dim('(or restart Zed)')}\n\n` +
+        `  ${color.dim('Run')} ${color.cyan('zedx check')} ${color.dim('to validate your extension.')}`);
+}

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

@@ -110,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})`)}`);
@@ -186,7 +186,7 @@ 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',
@@ -251,7 +251,7 @@ export async function runSync(opts = {}) {
         },
     };
     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

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 %>);

package/dist/templates/theme/theme.json.ejs

@@ -2,6 +2,7 @@
   "$schema": "https://zed.dev/schema/themes/v0.2.0.json",
   "name": "<%= themeName %>",
   "author": "<%= author %>",
+  "_todo": "TODO(edit-me): replace the placeholder grayscale colors in 'style' with your actual palette. Search for hex values like #d4d4d4ff to find them.",
   "themes": [
 <% appearances.forEach((app, index) => { %>
     {

package/package.json

@@ -1,59 +1,60 @@
 {
-  "name": "zedx",
-  "version": "0.7.0",
-  "description": "Scaffold Zed Editor extensions and sync your settings across machines.",
-  "keywords": [
-    "boilerplate",
-    "extension",
-    "scaffold",
-    "zed",
-    "zed-editor"
-  ],
-  "homepage": "https://github.com/tahayvr/zedx#readme",
-  "license": "Apache-2.0",
-  "author": "Taha Nejad <taha@noiserandom.com>",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/tahayvr/zedx.git"
-  },
-  "bin": {
-    "zedx": "dist/index.js"
-  },
-  "files": [
-    "dist"
-  ],
-  "type": "module",
-  "main": "dist/index.js",
-  "publishConfig": {
-    "access": "public"
-  },
-  "dependencies": {
-    "@clack/prompts": "^0.10.1",
-    "commander": "^14.0.3",
-    "ejs": "^4.0.1",
-    "fs-extra": "^11.3.3",
-    "picocolors": "^1.1.1",
-    "simple-git": "^3.33.0"
-  },
-  "devDependencies": {
-    "@types/ejs": "^3.1.5",
-    "@types/fs-extra": "^11.0.4",
-    "@types/node": "^25.2.3",
-    "oxfmt": "^0.42.0",
-    "oxlint": "^1.57.0",
-    "tsx": "^4.21.0",
-    "typescript": "^5.9.3"
-  },
-  "engines": {
-    "node": ">=18"
-  },
-  "scripts": {
-    "build": "tsc && cp -r src/templates dist/",
-    "start": "node dist/index.js",
-    "dev": "tsx src/index.ts",
-    "lint": "oxlint",
-    "lint:fix": "oxlint --fix",
-    "fmt": "oxfmt",
-    "fmt:check": "oxfmt --check"
-  }
-}
+    "name": "zedx",
+    "version": "0.8.0",
+    "description": "Scaffold Zed Editor extensions and sync your settings across machines.",
+    "keywords": [
+        "boilerplate",
+        "extension",
+        "scaffold",
+        "zed",
+        "zed-editor"
+    ],
+    "homepage": "https://github.com/tahayvr/zedx#readme",
+    "license": "Apache-2.0",
+    "author": "Taha Nejad <taha@noiserandom.com>",
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/tahayvr/zedx.git"
+    },
+    "bin": {
+        "zedx": "dist/index.js"
+    },
+    "files": [
+        "dist"
+    ],
+    "type": "module",
+    "main": "dist/index.js",
+    "publishConfig": {
+        "access": "public"
+    },
+    "scripts": {
+        "build": "tsc && cp -r src/templates dist/",
+        "start": "node dist/index.js",
+        "dev": "tsx src/index.ts",
+        "lint": "oxlint",
+        "lint:fix": "oxlint --fix",
+        "fmt": "oxfmt",
+        "fmt:check": "oxfmt --check"
+    },
+    "dependencies": {
+        "@clack/prompts": "^0.10.1",
+        "commander": "^14.0.3",
+        "ejs": "^4.0.1",
+        "fs-extra": "^11.3.3",
+        "picocolors": "^1.1.1",
+        "simple-git": "^3.33.0"
+    },
+    "devDependencies": {
+        "@types/ejs": "^3.1.5",
+        "@types/fs-extra": "^11.0.4",
+        "@types/node": "^25.2.3",
+        "oxfmt": "^0.42.0",
+        "oxlint": "^1.57.0",
+        "tsx": "^4.21.0",
+        "typescript": "^5.9.3"
+    },
+    "engines": {
+        "node": ">=18"
+    },
+    "packageManager": "pnpm@10.30.0+sha512.2b5753de015d480eeb88f5b5b61e0051f05b4301808a82ec8b840c9d2adf7748eb352c83f5c1593ca703ff1017295bc3fdd3119abb9686efc96b9fcb18200937"
+}