zedx 0.3.1 → 0.4.0

package/README.md

@@ -19,8 +19,14 @@ brew install tahayvr/tap/zedx
 # Create a new extension
 zedx
 
+# Add a theme or language to an existing extension
+zedx add theme "Midnight Blue"
+zedx add language rust
+
+# Validate extension config and show what is missing or incomplete
+zedx check
+
 # Bump extension version
-# Run inside extension dir
 zedx version patch   # 1.2.3 → 1.2.4
 zedx version minor   # 1.2.3 → 1.3.0
 zedx version major   # 1.2.3 → 2.0.0

package/dist/add.d.ts

@@ -0,0 +1,2 @@
+export declare function addTheme(callerDir: string, themeName: string): Promise<void>;
+export declare function addLanguage(callerDir: string, languageId: string): Promise<void>;

package/dist/add.js

@@ -0,0 +1,137 @@
+import fs from 'fs-extra';
+import path from 'path';
+import ejs from 'ejs';
+import { fileURLToPath } from 'url';
+import * as p from '@clack/prompts';
+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 slugify(name) {
+    return name.toLowerCase().replace(/\s+/g, '-').replace(/[^a-z0-9-]/g, '');
+}
+export async function addTheme(callerDir, themeName) {
+    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))) {
+        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') ?? 'extension';
+    const author = tomlGet(tomlContent, 'authors')
+        ?? tomlContent.match(/^authors\s*=\s*\["([^"]+)"\]/m)?.[1]
+        ?? '';
+    const appearance = await p.select({
+        message: 'Appearance:',
+        options: [
+            { value: 'dark', label: 'Dark' },
+            { value: 'light', label: 'Light' },
+            { value: 'both', label: 'Both (Dark & Light)' },
+        ],
+        initialValue: 'dark',
+    });
+    if (p.isCancel(appearance)) {
+        p.cancel('Cancelled.');
+        process.exit(0);
+    }
+    const appearances = appearance === 'both' ? ['dark', 'light'] : [appearance];
+    const themeSlug = slugify(themeName);
+    const themeFile = `${themeSlug}.json`;
+    const themesDir = path.join(callerDir, 'themes');
+    const themePath = path.join(themesDir, themeFile);
+    if (await fs.pathExists(themePath)) {
+        p.log.error(color.red(`themes/${themeFile} already exists.`));
+        process.exit(1);
+    }
+    await fs.ensureDir(themesDir);
+    const themeJson = await renderTemplate(path.join(TEMPLATE_DIR, 'theme/theme.json.ejs'), { id: extensionId, author, themeName, appearances });
+    await fs.writeFile(themePath, themeJson);
+    p.log.success(`Created ${color.cyan(`themes/${themeFile}`)}`);
+    p.outro(`${color.green('✓')} Theme added.\n` +
+        `${color.dim('Run')} ${color.cyan('zedx check')} ${color.dim('to validate your extension.')}`);
+}
+export async function addLanguage(callerDir, languageId) {
+    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))) {
+        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');
+    // Check for duplicate
+    const alreadyExists = new RegExp(`^\\[grammars\\.${languageId}\\]`, 'm').test(tomlContent)
+        || new RegExp(`^#\\s*\\[grammars\\.${languageId}\\]`, 'm').test(tomlContent);
+    if (alreadyExists) {
+        p.log.error(color.red(`Language "${languageId}" already exists in extension.toml.`));
+        process.exit(1);
+    }
+    const languageName = await p.text({
+        message: 'Language display name:',
+        placeholder: languageId,
+    });
+    if (p.isCancel(languageName)) {
+        p.cancel('Cancelled.');
+        process.exit(0);
+    }
+    const languageNameValue = String(languageName || languageId);
+    const langDir = path.join(callerDir, 'languages', languageId);
+    if (await fs.pathExists(langDir)) {
+        p.log.error(color.red(`languages/${languageId}/ already exists.`));
+        process.exit(1);
+    }
+    await fs.ensureDir(langDir);
+    // Write config.toml
+    const data = {
+        languageName: languageNameValue,
+        languageId,
+        pathSuffixes: [],
+        lineComments: ['//', '#'],
+        grammarRepo: '',
+        grammarRev: '',
+    };
+    const configToml = await renderTemplate(path.join(TEMPLATE_DIR, 'language/config.toml.ejs'), data);
+    await fs.writeFile(path.join(langDir, 'config.toml'), configToml);
+    p.log.success(`Created ${color.cyan(`languages/${languageId}/config.toml`)}`);
+    // Write .scm query files
+    const queryFiles = [
+        'highlights.scm',
+        'brackets.scm',
+        'outline.scm',
+        'indents.scm',
+        'injections.scm',
+        'overrides.scm',
+        'textobjects.scm',
+        'redactions.scm',
+        'runnables.scm',
+    ];
+    for (const file of queryFiles) {
+        const templatePath = path.join(TEMPLATE_DIR, 'language', file);
+        if (await fs.pathExists(templatePath)) {
+            const content = ejs.render(await fs.readFile(templatePath, 'utf-8'), data);
+            await fs.writeFile(path.join(langDir, file), content);
+        }
+    }
+    p.log.success(`Created ${color.cyan(`languages/${languageId}/`)} query files`);
+    // Append grammar block to extension.toml
+    const grammarBlock = `\n# [grammars.${languageId}]\n` +
+        `# repository = "https://github.com/user/tree-sitter-${languageId}"\n` +
+        `# rev = "main"\n` +
+        `\n# [language_servers.${languageId}-lsp]\n` +
+        `# name = "${languageNameValue} LSP"\n` +
+        `# languages = ["${languageNameValue}"]\n`;
+    await fs.appendFile(tomlPath, grammarBlock);
+    p.log.success(`Updated ${color.cyan('extension.toml')} with grammar block`);
+    p.outro(`${color.green('✓')} Language added.\n` +
+        `${color.dim('Run')} ${color.cyan('zedx check')} ${color.dim('to validate your extension.')}`);
+}

package/dist/check.d.ts

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

package/dist/check.js

@@ -0,0 +1,243 @@
+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`);
+}

package/dist/dev.d.ts

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

package/dist/dev.js

@@ -0,0 +1,243 @@
+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`);
+}

package/dist/index.js

@@ -6,6 +6,8 @@ import { Command } from 'commander';
 import fs from 'fs-extra';
 import { promptUser, promptThemeDetails, promptLanguageDetails } from './prompts.js';
 import { generateExtension } from './generator.js';
+import { runCheck } from './check.js';
+import { addTheme, addLanguage } from './add.js';
 function bumpVersion(version, type) {
     const [major, minor, patch] = version.split('.').map(Number);
     switch (type) {
@@ -53,6 +55,27 @@ async function main() {
         }
         await bumpExtensionVersion(type);
     });
+    program
+        .command('check')
+        .description('Validate extension config and show what is missing or incomplete')
+        .action(async () => {
+        await runCheck(getCallerDir());
+    });
+    const addCmd = program
+        .command('add')
+        .description('Add a theme or language to an existing extension');
+    addCmd
+        .command('theme <name>')
+        .description('Add a new theme to the extension')
+        .action(async (name) => {
+        await addTheme(getCallerDir(), name);
+    });
+    addCmd
+        .command('language <id>')
+        .description('Add a new language to the extension')
+        .action(async (id) => {
+        await addLanguage(getCallerDir(), id);
+    });
     if (process.argv.length <= 2) {
         const options = await promptUser();
         if (options.types.includes('theme')) {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "zedx",
-	"version": "0.3.1",
+	"version": "0.4.0",
 	"description": "Boilerplate generator for Zed Edittor extensions.",
 	"type": "module",
 	"main": "dist/index.js",