zedx 0.7.0 → 0.8.1

package/README.md

@@ -17,7 +17,7 @@ brew install tahayvr/tap/zedx
 
 ```bash
 # Create a new extension
-zedx
+zedx create
 
 # Add a theme or language to an existing extension
 zedx add theme "Midnight Blue"

package/dist/add.js

@@ -24,6 +24,7 @@ function slugify(name) {
         .replace(/[^a-z0-9-]/g, '');
 }
 export async function addTheme(callerDir, themeName) {
+    console.log('');
     p.intro(`${color.bgBlue(color.bold(' zedx add theme '))} ${color.blue('Adding a theme to your extension…')}`);
     const tomlPath = path.join(callerDir, 'extension.toml');
     if (!(await fs.pathExists(tomlPath))) {
@@ -70,6 +71,7 @@ export async function addTheme(callerDir, themeName) {
         `${color.dim('Run')} ${color.cyan('zedx check')} ${color.dim('to validate your extension.')}`);
 }
 export async function addLanguage(callerDir, languageId) {
+    console.log('');
     p.intro(`${color.bgBlue(color.bold(' zedx add language '))} ${color.blue('Adding a language to your extension…')}`);
     const tomlPath = path.join(callerDir, 'extension.toml');
     if (!(await fs.pathExists(tomlPath))) {

package/dist/check.js

@@ -11,6 +11,7 @@ function tomlHasUncommentedKey(content, key) {
     return new RegExp(`^${key}\\s*=`, 'm').test(content);
 }
 export async function runCheck(callerDir) {
+    console.log('');
     p.intro(`${color.bgBlue(color.bold(' zedx check '))} ${color.blue('Validating extension config…')}`);
     const tomlPath = path.join(callerDir, 'extension.toml');
     if (!(await fs.pathExists(tomlPath))) {

package/dist/daemon.js

@@ -151,6 +151,7 @@ async function uninstallLinux() {
     p.log.success('Daemon uninstalled.');
 }
 export async function syncInstall() {
+    console.log('');
     p.intro(color.bold('zedx sync install'));
     const platform = process.platform;
     if (platform !== 'darwin' && platform !== 'linux')
@@ -173,6 +174,7 @@ export async function syncInstall() {
         `  Run ${color.cyan('zedx sync uninstall')} to remove the daemon at any time.`);
 }
 export async function syncUninstall() {
+    console.log('');
     p.intro(color.bold('zedx sync uninstall'));
     const platform = process.platform;
     if (platform !== 'darwin' && platform !== 'linux')

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,189 @@
+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) {
+    console.log('');
+    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/prompts.js

@@ -1,7 +1,8 @@
 import * as p from '@clack/prompts';
 import color from 'picocolors';
 export async function promptUser() {
-    p.intro(`${color.bgBlue(color.bold(' zedx '))} ${color.blue('Boilerplate generator for Zed Editor extensions.')}`);
+    console.log('');
+    p.intro(`${color.bgBlue(color.bold(' zedx create '))} ${color.blue('Boilerplate generator for Zed Editor extensions.')}`);
     const nameDefault = 'my-zed-extension';
     const name = await p.text({
         message: 'Project name:',

package/dist/snippet.d.ts

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

package/dist/snippet.js

@@ -0,0 +1,169 @@
+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) {
+    console.log('');
+    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,8 @@ async function applyRemoteSettings(repoSettings, repoExtensions, localSettingsPa
 }
 // zedx sync status
 export async function syncStatus() {
-    p.intro(color.bold('zedx sync status'));
+    console.log('');
+    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 +187,8 @@ export async function syncStatus() {
 }
 // zedx sync init
 export async function syncInit() {
-    p.intro(color.bold('zedx sync init'));
+    console.log('');
+    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',
@@ -250,8 +252,10 @@ export async function runSync(opts = {}) {
                 p.log.success(msg);
         },
     };
-    if (!silent)
-        p.intro(color.bold('zedx sync'));
+    if (!silent) {
+        console.log('');
+        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.1",
+    "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"
+}

package/dist/dev.d.ts

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

package/dist/dev.js

@@ -1,243 +0,0 @@
-import fs from 'fs-extra';
-import path from 'path';
-import * as p from '@clack/prompts';
-import color from 'picocolors';
-// Minimal TOML key extraction — handles `key = "value"` and `key = ["a", "b"]`
-function tomlGet(content, key) {
-    const match = content.match(new RegExp(`^${key}\\s*=\\s*"([^"]*)"`, 'm'));
-    return match?.[1];
-}
-function tomlHasUncommentedKey(content, key) {
-    return new RegExp(`^${key}\\s*=`, 'm').test(content);
-}
-function tomlHasSection(content, section) {
-    // Looks for an uncommented [section] or [section.something] header
-    return new RegExp(`^\\[${section.replace('.', '\\.')}`, 'm').test(content);
-}
-export async function runCheck(callerDir) {
-    p.intro(`${color.bgBlue(color.bold(' zedx check '))} ${color.blue('Validating extension config…')}`);
-    const tomlPath = path.join(callerDir, 'extension.toml');
-    if (!(await fs.pathExists(tomlPath))) {
-        p.log.error(color.red('No extension.toml found in current directory.'));
-        p.log.info(`Run ${color.cyan('zedx')} to scaffold a new extension first.`);
-        process.exit(1);
-    }
-    const tomlContent = await fs.readFile(tomlPath, 'utf-8');
-    const extensionId = tomlGet(tomlContent, 'id');
-    const extensionName = tomlGet(tomlContent, 'name');
-    const repository = tomlGet(tomlContent, 'repository');
-    const results = [];
-    // ── extension.toml ────────────────────────────────────────────────────────
-    const extIssues = [];
-    if (!extensionId) {
-        extIssues.push({
-            file: 'extension.toml',
-            message: 'Missing required field: id',
-        });
-    }
-    if (!extensionName) {
-        extIssues.push({
-            file: 'extension.toml',
-            message: 'Missing required field: name',
-        });
-    }
-    if (!repository || repository.includes('username')) {
-        extIssues.push({
-            file: 'extension.toml',
-            message: 'repository still uses the default placeholder URL',
-            hint: 'Set it to your actual GitHub repository URL',
-        });
-    }
-    // Detect language entries by looking for uncommented [grammars.*] sections
-    const grammarMatches = [...tomlContent.matchAll(/^\[grammars\.(\S+)\]/gm)];
-    const commentedGrammarMatches = [...tomlContent.matchAll(/^#\s*\[grammars\.(\S+)\]/gm)];
-    const languageIds = grammarMatches.map(m => m[1]);
-    const hasLanguage = languageIds.length > 0 || commentedGrammarMatches.length > 0;
-    if (commentedGrammarMatches.length > 0 && grammarMatches.length === 0) {
-        const ids = commentedGrammarMatches.map(m => m[1]);
-        extIssues.push({
-            file: 'extension.toml',
-            message: `Grammar section is commented out for: ${ids.join(', ')}`,
-            hint: 'Uncomment [grammars.<id>] and set a real tree-sitter repository URL and rev',
-        });
-    }
-    // Detect theme entries by looking for themes/ directory
-    const themesDir = path.join(callerDir, 'themes');
-    const hasTheme = await fs.pathExists(themesDir);
-    results.push({ file: 'extension.toml', issues: extIssues });
-    // ── theme validation ──────────────────────────────────────────────────────
-    if (hasTheme) {
-        const themeIssues = [];
-        const themeFiles = (await fs.readdir(themesDir)).filter(f => f.endsWith('.json'));
-        if (themeFiles.length === 0) {
-            themeIssues.push({
-                file: 'themes/',
-                message: 'No .json theme files found in themes/ directory',
-            });
-        }
-        for (const themeFile of themeFiles) {
-            const themePath = path.join(themesDir, themeFile);
-            const themeIssuesForFile = [];
-            let themeJson;
-            try {
-                themeJson = await fs.readJson(themePath);
-            }
-            catch {
-                themeIssuesForFile.push({
-                    file: `themes/${themeFile}`,
-                    message: 'Invalid JSON — file could not be parsed',
-                });
-                results.push({ file: `themes/${themeFile}`, issues: themeIssuesForFile });
-                continue;
-            }
-            const themes = themeJson['themes'];
-            if (!themes || themes.length === 0) {
-                themeIssuesForFile.push({
-                    file: `themes/${themeFile}`,
-                    message: 'No theme variants found under the "themes" key',
-                });
-            }
-            else {
-                for (const variant of themes) {
-                    const variantName = String(variant['name'] ?? 'unknown');
-                    const style = variant['style'];
-                    if (!style) {
-                        themeIssuesForFile.push({
-                            file: `themes/${themeFile}`,
-                            message: `Variant "${variantName}": missing "style" block`,
-                        });
-                        continue;
-                    }
-                    // Check for placeholder-like neutral grays that indicate untouched scaffold
-                    const background = style['background'];
-                    const placeholderBgs = ['#1e1e1e', '#f5f5f5', '#ffffff', '#000000'];
-                    if (background && placeholderBgs.includes(background.toLowerCase())) {
-                        themeIssuesForFile.push({
-                            file: `themes/${themeFile}`,
-                            message: `Variant "${variantName}": background color is still the scaffold placeholder (${background})`,
-                            hint: 'Replace with your actual theme colors',
-                        });
-                    }
-                    // Check that syntax block is populated
-                    const syntax = style['syntax'];
-                    if (!syntax || Object.keys(syntax).length === 0) {
-                        themeIssuesForFile.push({
-                            file: `themes/${themeFile}`,
-                            message: `Variant "${variantName}": "syntax" block is empty or missing`,
-                            hint: 'Add syntax token color definitions',
-                        });
-                    }
-                }
-            }
-            themeIssues.push(...themeIssuesForFile);
-        }
-        results.push({ file: 'themes/', issues: themeIssues });
-    }
-    // ── language validation ───────────────────────────────────────────────────
-    if (hasLanguage) {
-        // Collect all language IDs from both uncommented and commented grammar sections
-        const allLanguageIds = [
-            ...grammarMatches.map(m => m[1]),
-            ...commentedGrammarMatches.map(m => m[1]),
-        ];
-        for (const langId of allLanguageIds) {
-            const langDir = path.join(callerDir, 'languages', langId);
-            const langIssues = [];
-            if (!(await fs.pathExists(langDir))) {
-                langIssues.push({
-                    file: `languages/${langId}/`,
-                    message: `Language directory does not exist`,
-                    hint: `Expected at ${path.join('languages', langId)}`,
-                });
-                results.push({ file: `languages/${langId}/`, issues: langIssues });
-                continue;
-            }
-            // config.toml checks
-            const configPath = path.join(langDir, 'config.toml');
-            const configIssues = [];
-            if (!(await fs.pathExists(configPath))) {
-                configIssues.push({
-                    file: `languages/${langId}/config.toml`,
-                    message: 'config.toml is missing',
-                });
-            }
-            else {
-                const configContent = await fs.readFile(configPath, 'utf-8');
-                if (!tomlHasUncommentedKey(configContent, 'name')) {
-                    configIssues.push({
-                        file: `languages/${langId}/config.toml`,
-                        message: 'Missing required field: name',
-                    });
-                }
-                if (!tomlHasUncommentedKey(configContent, 'grammar')) {
-                    configIssues.push({
-                        file: `languages/${langId}/config.toml`,
-                        message: 'Missing required field: grammar',
-                    });
-                }
-                // path_suffixes is commented out in scaffold — flag it
-                if (!tomlHasUncommentedKey(configContent, 'path_suffixes')) {
-                    configIssues.push({
-                        file: `languages/${langId}/config.toml`,
-                        message: 'path_suffixes is not set — files won\'t be associated with this language',
-                        hint: 'Uncomment and fill in path_suffixes (e.g., ["myl"])',
-                    });
-                }
-                // line_comments is commented out in scaffold — flag it
-                if (!tomlHasUncommentedKey(configContent, 'line_comments')) {
-                    configIssues.push({
-                        file: `languages/${langId}/config.toml`,
-                        message: 'line_comments is not set — toggle-comment keybind won\'t work',
-                        hint: 'Uncomment and set line_comments (e.g., ["// "])',
-                    });
-                }
-            }
-            results.push({ file: `languages/${langId}/config.toml`, issues: configIssues });
-            // highlights.scm checks
-            const highlightsPath = path.join(langDir, 'highlights.scm');
-            const highlightIssues = [];
-            if (!(await fs.pathExists(highlightsPath))) {
-                highlightIssues.push({
-                    file: `languages/${langId}/highlights.scm`,
-                    message: 'highlights.scm is missing',
-                    hint: 'Without it, no syntax highlighting will appear',
-                });
-            }
-            else {
-                const highlightsContent = await fs.readFile(highlightsPath, 'utf-8');
-                // Count non-comment, non-empty lines with actual query patterns
-                const activeLines = highlightsContent
-                    .split('\n')
-                    .filter(l => l.trim() && !l.trim().startsWith(';'));
-                if (activeLines.length <= 3) {
-                    highlightIssues.push({
-                        file: `languages/${langId}/highlights.scm`,
-                        message: 'Only scaffold starter patterns present — no real grammar queries added yet',
-                        hint: 'Add tree-sitter queries matching your language\'s grammar node types',
-                    });
-                }
-            }
-            results.push({ file: `languages/${langId}/highlights.scm`, issues: highlightIssues });
-        }
-    }
-    // ── render results ────────────────────────────────────────────────────────
-    const allIssues = results.flatMap(r => r.issues);
-    const fileGroups = results.filter(r => r.issues.length > 0);
-    if (fileGroups.length === 0) {
-        p.log.success(color.green('No issues found. Your extension config looks good!'));
-        p.outro(`${color.dim('Load it in Zed:')} Extensions ${color.dim('>')} Install Dev Extension`);
-        return;
-    }
-    for (const group of fileGroups) {
-        p.log.warn(`${color.yellow(color.bold(group.issues[0].file))}`);
-        for (const issue of group.issues) {
-            process.stdout.write(`  ${color.red('✗')} ${issue.message}\n`);
-            if (issue.hint) {
-                process.stdout.write(`    ${color.dim('→')} ${color.dim(issue.hint)}\n`);
-            }
-        }
-        process.stdout.write('\n');
-    }
-    const issueCount = allIssues.length;
-    p.outro(`${color.red(`${issueCount} issue${issueCount === 1 ? '' : 's'} found`)} — fix the above before publishing`);
-}