zedx 0.8.0 → 0.9.0

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"
@@ -33,7 +33,9 @@ zedx version major   # 1.2.3 → 2.0.0
 
 # Sync Zed settings and extensions via a GitHub repo
 zedx sync init       # Link a GitHub repo as the sync target (run once)
-zedx sync            # Sync local and remote config automatically
+zedx sync            # Sync local and remote config (prompts on conflict)
+zedx sync --local    # Sync, always keeping local on conflict
+zedx sync --remote   # Sync, always using remote on conflict
 zedx sync status     # Show sync state between local config and the remote repo
 zedx sync install    # Install an OS daemon to auto-sync when Zed config changes
 zedx sync uninstall  # Remove the OS daemon

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

@@ -1,4 +1,5 @@
 #!/usr/bin/env node
+import { createRequire } from 'module';
 import path from 'path';
 import * as p from '@clack/prompts';
 import { Command } from 'commander';
@@ -11,7 +12,9 @@ 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';
+import { syncInit, runSync, syncStatus, syncSelect } from './sync.js';
+const require = createRequire(import.meta.url);
+const { version } = require('../package.json');
 function bumpVersion(version, type) {
     const [major, minor, patch] = version.split('.').map(Number);
     switch (type) {
@@ -65,6 +68,7 @@ function printWelcome() {
         ['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 select', 'Choose which files to sync interactively'],
         ['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'],
@@ -74,7 +78,7 @@ function printWelcome() {
     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`);
+    console.log(`\n  ${color.dim('Zed Docs:')} ${color.underline(color.blue('https://zed.dev/docs/extensions'))}\n`);
 }
 async function runCreate() {
     const options = await promptUser();
@@ -99,7 +103,7 @@ async function runCreate() {
 }
 async function main() {
     const program = new Command();
-    program.name('zedx').description('The CLI toolkit for Zed Editor.').helpOption(false);
+    program.name('zedx').description('The CLI toolkit for Zed Editor.').version(`zedx v${version}`);
     program
         .command('create')
         .description('Scaffold a new Zed extension')
@@ -156,8 +160,19 @@ async function main() {
     const syncCmd = program
         .command('sync')
         .description('Sync Zed settings and extensions via a GitHub repo')
-        .action(async () => {
-        await runSync();
+        .option('--local', 'On conflict, always keep the local version')
+        .option('--remote', 'On conflict, always use the remote version')
+        .action(async (opts) => {
+        if (opts.local && opts.remote) {
+            p.log.error(color.red('--local and --remote are mutually exclusive.'));
+            process.exit(1);
+        }
+        const conflict = opts.local
+            ? 'local'
+            : opts.remote
+                ? 'remote'
+                : 'prompt';
+        await runSync({ conflict });
     });
     syncCmd
         .command('init')
@@ -171,6 +186,12 @@ async function main() {
         .action(async () => {
         await syncStatus();
     });
+    syncCmd
+        .command('select')
+        .description('Interactively choose which files to sync')
+        .action(async () => {
+        await syncSelect();
+    });
     syncCmd
         .command('install')
         .description('Install the OS daemon to auto-sync when Zed config changes')
@@ -183,10 +204,11 @@ async function main() {
         .action(async () => {
         await syncUninstall();
     });
-    if (process.argv.length <= 2) {
+    const argv = process.argv.filter(arg => arg !== '--');
+    if (argv.length <= 2) {
         printWelcome();
         return;
     }
-    program.parse(process.argv);
+    program.parse(argv);
 }
 main().catch(console.error);

package/dist/install.js

@@ -112,6 +112,7 @@ function buildManifest(extensionDir, toml) {
 }
 // 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))) {

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.js

@@ -37,6 +37,7 @@ function detectLanguages(callerDir) {
     }
 }
 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))) {
@@ -164,5 +165,5 @@ export async function addLsp(callerDir) {
     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'))}`);
+        `  ${color.dim('3.')} ${color.dim('Zed Docs:')} ${color.underline(color.blue('https://zed.dev/docs/extensions/languages#language-servers'))}`);
 }

package/dist/sync.d.ts

@@ -1,5 +1,9 @@
 export declare function syncStatus(): Promise<void>;
 export declare function syncInit(): Promise<void>;
+export type ConflictStrategy = 'local' | 'remote' | 'prompt';
+export declare function syncSelect(): Promise<void>;
 export declare function runSync(opts?: {
     silent?: boolean;
+    conflict?: ConflictStrategy;
+    selectedFiles?: string[];
 }): Promise<void>;

package/dist/sync.js

@@ -110,6 +110,7 @@ async function applyRemoteSettings(repoSettings, repoExtensions, localSettingsPa
 }
 // zedx sync status
 export async function syncStatus() {
+    console.log('');
     p.intro(`${color.bgBlue(color.bold(' zedx sync status '))} ${color.blue('Checking sync state…')}`);
     const config = await requireSyncConfig();
     const zedPaths = resolveZedPaths();
@@ -186,6 +187,7 @@ export async function syncStatus() {
 }
 // zedx sync init
 export async function syncInit() {
+    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)',
@@ -229,9 +231,38 @@ export async function syncInit() {
     p.outro(`${color.green('✓')} Sync config saved to ${color.cyan(ZEDX_CONFIG_PATH)}\n\n` +
         `  Run ${color.cyan('zedx sync')} to sync your Zed config.`);
 }
+// zedx sync select
+export async function syncSelect() {
+    console.log('');
+    p.intro(`${color.bgBlue(color.bold(' zedx sync select '))} ${color.blue('Choose which files to sync…')}`);
+    await requireSyncConfig();
+    const allFiles = [
+        {
+            value: 'settings',
+            label: 'settings.json',
+            hint: 'Zed editor settings',
+        },
+        {
+            value: 'extensions',
+            label: 'extensions/index.json',
+            hint: 'Installed extensions list',
+        },
+    ];
+    const selected = await p.multiselect({
+        message: 'Select files to sync',
+        options: allFiles,
+        required: true,
+    });
+    if (p.isCancel(selected)) {
+        p.cancel('Cancelled.');
+        process.exit(0);
+    }
+    const selectedFiles = selected;
+    await runSync({ selectedFiles });
+}
 // zedx sync
 export async function runSync(opts = {}) {
-    const { silent = false } = opts;
+    const { silent = false, conflict = 'prompt', selectedFiles } = opts;
     // In silent mode (daemon/watch), route all UI through plain console.log
     // Interactive conflict prompts fall back to "local wins".
     const log = {
@@ -250,8 +281,10 @@ export async function runSync(opts = {}) {
                 p.log.success(msg);
         },
     };
-    if (!silent)
+    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
@@ -278,18 +311,23 @@ export async function runSync(opts = {}) {
         }
         // 2. Determine what changed for each file
         const lastSync = config.lastSync ? new Date(config.lastSync) : null;
-        const files = [
+        const allFiles = [
             {
+                key: 'settings',
                 repoPath: path.join(tmp, 'settings.json'),
                 localPath: zedPaths.settings,
                 label: 'settings.json',
             },
             {
+                key: 'extensions',
                 repoPath: path.join(tmp, 'extensions', 'index.json'),
                 localPath: zedPaths.extensions,
                 label: 'extensions/index.json',
             },
         ];
+        const files = selectedFiles
+            ? allFiles.filter(f => selectedFiles.includes(f.key))
+            : allFiles;
         let anyChanges = false;
         for (const file of files) {
             const localExists = await fs.pathExists(file.localPath);
@@ -362,18 +400,20 @@ export async function runSync(opts = {}) {
                 }
             }
             else {
-                // Both changed
-                if (silent) {
+                // Both changed — resolve based on strategy
+                // Determine the effective resolution:
+                //   - explicit --local / --remote flag always wins
+                //   - silent (daemon) mode falls back to local
+                //   - otherwise prompt interactively
+                let resolution;
+                if (conflict === 'local' || conflict === 'remote') {
+                    resolution = conflict;
+                    log.warn(`${file.label}: conflict — using ${color.bold(resolution)} (--${resolution} flag).`);
+                }
+                else if (silent) {
                     // Daemon can't prompt — local wins, will be pushed
+                    resolution = 'local';
                     log.warn(`${file.label}: conflict detected in unattended mode — keeping local.`);
-                    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(`conflict between local and remote ${file.label}`));
@@ -396,26 +436,29 @@ export async function runSync(opts = {}) {
                         p.cancel('Cancelled.');
                         process.exit(0);
                     }
-                    if (choice === 'local') {
+                    resolution = choice;
+                }
+                if (resolution === 'local') {
+                    if (!silent && conflict === 'prompt')
                         p.log.info(`${file.label}: ${color.green('keeping local, will push')}`);
-                        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;
+                    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 (!silent && conflict === 'prompt')
                         p.log.info(`${file.label}: ${color.cyan('applying remote')}`);
-                        if (file.label === 'settings.json') {
-                            await applyRemoteSettings(file.repoPath, path.join(tmp, 'extensions', 'index.json'), file.localPath, silent);
-                        }
-                        else {
-                            await fs.ensureDir(path.dirname(file.localPath));
-                            await fs.copy(file.repoPath, file.localPath, { overwrite: true });
-                        }
+                    if (file.label === 'settings.json') {
+                        await applyRemoteSettings(file.repoPath, path.join(tmp, 'extensions', 'index.json'), file.localPath, silent);
+                    }
+                    else {
+                        await fs.ensureDir(path.dirname(file.localPath));
+                        await fs.copy(file.repoPath, file.localPath, { overwrite: true });
                     }
                 }
             }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "zedx",
-    "version": "0.8.0",
+    "version": "0.9.0",
     "description": "Scaffold Zed Editor extensions and sync your settings across machines.",
     "keywords": [
         "boilerplate",

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`);
-}