zedx 0.8.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/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))) {

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)',
@@ -250,8 +252,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

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "zedx",
-    "version": "0.8.0",
+    "version": "0.8.1",
     "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`);
-}