zedx 0.3.1 → 0.5.0

package/README.md

@@ -1,6 +1,6 @@
 # zedx
 
-Boilerplate generator for [Zed Editor](https://zed.dev/) extensions.
+Scaffold [Zed Editor](https://zed.dev/) extensions and sync your settings across machines.
 
 ![screenshot](./assets/screenshot1.png)
 
@@ -19,11 +19,23 @@ 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
+
+# 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 install    # Install an OS daemon to auto-sync when Zed config changes
+zedx sync uninstall  # Remove the OS daemon
 ```
 
 ### Supported extension types:

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/daemon.d.ts

@@ -0,0 +1,2 @@
+export declare function syncInstall(): Promise<void>;
+export declare function syncUninstall(): Promise<void>;

package/dist/daemon.js

@@ -0,0 +1,183 @@
+import os from 'os';
+import path from 'path';
+import fs from 'fs-extra';
+import { execSync } from 'child_process';
+import * as p from '@clack/prompts';
+import color from 'picocolors';
+import { resolveZedPaths } from './zed-paths.js';
+const LAUNCHD_LABEL = 'dev.zedx.sync';
+const LAUNCHD_PLIST_PATH = path.join(os.homedir(), 'Library', 'LaunchAgents', `${LAUNCHD_LABEL}.plist`);
+const SYSTEMD_SERVICE_NAME = 'zedx-sync';
+const SYSTEMD_UNIT_DIR = path.join(os.homedir(), '.config', 'systemd', 'user');
+const SYSTEMD_SERVICE_PATH = path.join(SYSTEMD_UNIT_DIR, `${SYSTEMD_SERVICE_NAME}.service`);
+const SYSTEMD_PATH_PATH = path.join(SYSTEMD_UNIT_DIR, `${SYSTEMD_SERVICE_NAME}.path`);
+function resolveZedxBinary() {
+    try {
+        const bin = execSync('which zedx', { encoding: 'utf-8' }).trim();
+        if (bin)
+            return bin;
+    }
+    catch { /* fall through */ }
+    return `${process.execPath} ${process.argv[1]}`;
+}
+function unsupportedPlatform() {
+    p.log.error(color.red(`zedx sync install is only supported on macOS and Linux.`));
+    process.exit(1);
+}
+function buildPlist(zedxBin, watchPaths) {
+    const watchEntries = watchPaths
+        .map((wp) => `        <string>${wp}</string>`)
+        .join('\n');
+    return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+    <key>Label</key>
+    <string>${LAUNCHD_LABEL}</string>
+
+    <key>ProgramArguments</key>
+    <array>
+        <string>${zedxBin}</string>
+        <string>sync</string>
+    </array>
+
+    <key>RunAtLoad</key>
+    <true/>
+
+    <key>WatchPaths</key>
+    <array>
+${watchEntries}
+    </array>
+
+    <key>ThrottleInterval</key>
+    <integer>30</integer>
+
+    <key>StandardOutPath</key>
+    <string>${os.homedir()}/Library/Logs/zedx-sync.log</string>
+
+    <key>StandardErrorPath</key>
+    <string>${os.homedir()}/Library/Logs/zedx-sync.log</string>
+</dict>
+</plist>
+`;
+}
+async function installMacos(zedxBin, watchPaths) {
+    const plist = buildPlist(zedxBin, watchPaths);
+    await fs.ensureDir(path.dirname(LAUNCHD_PLIST_PATH));
+    await fs.writeFile(LAUNCHD_PLIST_PATH, plist, 'utf-8');
+    try {
+        execSync(`launchctl unload "${LAUNCHD_PLIST_PATH}" 2>/dev/null`, { stdio: 'pipe' });
+    }
+    catch { /* not loaded yet */ }
+    execSync(`launchctl load "${LAUNCHD_PLIST_PATH}"`);
+    p.log.success(`Daemon installed: ${color.dim(LAUNCHD_PLIST_PATH)}`);
+    p.log.info(`Logs: ${color.dim(`${os.homedir()}/Library/Logs/zedx-sync.log`)}`);
+    p.log.info(`To check status: ${color.cyan(`launchctl list ${LAUNCHD_LABEL}`)}`);
+}
+async function uninstallMacos() {
+    if (!(await fs.pathExists(LAUNCHD_PLIST_PATH))) {
+        p.log.warn(color.yellow('No launchd agent found — nothing to uninstall.'));
+        return;
+    }
+    try {
+        execSync(`launchctl unload "${LAUNCHD_PLIST_PATH}"`, { stdio: 'pipe' });
+    }
+    catch { /* already unloaded */ }
+    await fs.remove(LAUNCHD_PLIST_PATH);
+    p.log.success('Daemon uninstalled.');
+}
+function buildSystemdService(zedxBin) {
+    return `[Unit]
+Description=zedx Zed config sync
+After=network-online.target
+Wants=network-online.target
+
+[Service]
+Type=oneshot
+ExecStart=${zedxBin} sync
+StandardOutput=journal
+StandardError=journal
+
+[Install]
+WantedBy=default.target
+`;
+}
+function buildSystemdPath(watchPaths) {
+    const pathChangedEntries = watchPaths
+        .map((wp) => `PathChanged=${wp}`)
+        .join('\n');
+    return `[Unit]
+Description=Watch Zed config files for zedx sync
+
+[Path]
+${pathChangedEntries}
+Unit=${SYSTEMD_SERVICE_NAME}.service
+
+[Install]
+WantedBy=default.target
+`;
+}
+async function installLinux(zedxBin, watchPaths) {
+    await fs.ensureDir(SYSTEMD_UNIT_DIR);
+    await fs.writeFile(SYSTEMD_SERVICE_PATH, buildSystemdService(zedxBin), 'utf-8');
+    await fs.writeFile(SYSTEMD_PATH_PATH, buildSystemdPath(watchPaths), 'utf-8');
+    execSync('systemctl --user daemon-reload');
+    execSync(`systemctl --user enable --now ${SYSTEMD_SERVICE_NAME}.path`);
+    p.log.success(`Service installed: ${color.dim(SYSTEMD_SERVICE_PATH)}`);
+    p.log.success(`Path unit installed: ${color.dim(SYSTEMD_PATH_PATH)}`);
+    p.log.info(`To check status: ${color.cyan(`systemctl --user status ${SYSTEMD_SERVICE_NAME}.path`)}`);
+    p.log.info(`Logs: ${color.cyan(`journalctl --user -u ${SYSTEMD_SERVICE_NAME}.service`)}`);
+}
+async function uninstallLinux() {
+    const serviceExists = await fs.pathExists(SYSTEMD_SERVICE_PATH);
+    const pathExists = await fs.pathExists(SYSTEMD_PATH_PATH);
+    if (!serviceExists && !pathExists) {
+        p.log.warn(color.yellow('No systemd units found — nothing to uninstall.'));
+        return;
+    }
+    try {
+        execSync(`systemctl --user disable --now ${SYSTEMD_SERVICE_NAME}.path`, { stdio: 'pipe' });
+    }
+    catch { /* already inactive */ }
+    if (serviceExists)
+        await fs.remove(SYSTEMD_SERVICE_PATH);
+    if (pathExists)
+        await fs.remove(SYSTEMD_PATH_PATH);
+    execSync('systemctl --user daemon-reload', { stdio: 'pipe' });
+    p.log.success('Daemon uninstalled.');
+}
+export async function syncInstall() {
+    p.intro(color.bold('zedx sync install'));
+    const platform = process.platform;
+    if (platform !== 'darwin' && platform !== 'linux')
+        unsupportedPlatform();
+    const zedPaths = resolveZedPaths();
+    const watchPaths = [zedPaths.settings, zedPaths.extensions];
+    const zedxBin = resolveZedxBinary();
+    p.log.info(`Binary:  ${color.dim(zedxBin)}`);
+    p.log.info(`Watching:`);
+    for (const wp of watchPaths) {
+        p.log.info(`  ${color.dim(wp)}`);
+    }
+    if (platform === 'darwin') {
+        await installMacos(zedxBin, watchPaths);
+    }
+    else {
+        await installLinux(zedxBin, watchPaths);
+    }
+    p.outro(`${color.green('✓')} zedx sync will now run automatically whenever your Zed config changes.\n\n` +
+        `  Run ${color.cyan('zedx sync uninstall')} to remove the daemon at any time.`);
+}
+export async function syncUninstall() {
+    p.intro(color.bold('zedx sync uninstall'));
+    const platform = process.platform;
+    if (platform !== 'darwin' && platform !== 'linux')
+        unsupportedPlatform();
+    if (platform === 'darwin') {
+        await uninstallMacos();
+    }
+    else {
+        await uninstallLinux();
+    }
+    p.outro(`${color.green('✓')} Done.`);
+}

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,10 @@ 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';
+import { syncInit, runSync } from './sync.js';
+import { syncInstall, syncUninstall } from './daemon.js';
 function bumpVersion(version, type) {
     const [major, minor, patch] = version.split('.').map(Number);
     switch (type) {
@@ -53,6 +57,51 @@ 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);
+    });
+    const syncCmd = program
+        .command('sync')
+        .description('Sync Zed settings and extensions via a GitHub repo')
+        .action(async () => {
+        await runSync();
+    });
+    syncCmd
+        .command('init')
+        .description('Link a GitHub repo as the sync target')
+        .action(async () => {
+        await syncInit();
+    });
+    syncCmd
+        .command('install')
+        .description('Install the OS daemon to auto-sync when Zed config changes')
+        .action(async () => {
+        await syncInstall();
+    });
+    syncCmd
+        .command('uninstall')
+        .description('Remove the OS daemon')
+        .action(async () => {
+        await syncUninstall();
+    });
     if (process.argv.length <= 2) {
         const options = await promptUser();
         if (options.types.includes('theme')) {

package/dist/sync.d.ts

@@ -0,0 +1,4 @@
+export declare function syncInit(): Promise<void>;
+export declare function runSync(opts?: {
+    silent?: boolean;
+}): Promise<void>;

package/dist/sync.js

@@ -0,0 +1,317 @@
+import os from 'os';
+import path from 'path';
+import fs from 'fs-extra';
+import * as p from '@clack/prompts';
+import color from 'picocolors';
+import simpleGit from 'simple-git';
+import { resolveZedPaths } from './zed-paths.js';
+const ZEDX_CONFIG_DIR = path.join(os.homedir(), '.config', 'zedx');
+const ZEDX_CONFIG_PATH = path.join(ZEDX_CONFIG_DIR, 'config.json');
+async function readSyncConfig() {
+    if (!(await fs.pathExists(ZEDX_CONFIG_PATH))) {
+        return null;
+    }
+    return fs.readJson(ZEDX_CONFIG_PATH);
+}
+async function requireSyncConfig() {
+    const config = await readSyncConfig();
+    if (!config) {
+        p.log.error(color.red('No sync config found. Run ') + color.cyan('zedx sync init') + color.red(' first.'));
+        process.exit(1);
+    }
+    return config;
+}
+async function writeSyncConfig(config) {
+    await fs.ensureDir(ZEDX_CONFIG_DIR);
+    await fs.writeJson(ZEDX_CONFIG_PATH, config, { spaces: 4 });
+}
+// Temp dir helper
+async function withTempDir(fn) {
+    const tmp = await fs.mkdtemp(path.join(os.tmpdir(), 'zedx-sync-'));
+    try {
+        return await fn(tmp);
+    }
+    finally {
+        await fs.remove(tmp);
+    }
+}
+// Extension merge helper
+async function applyRemoteSettings(repoSettings, repoExtensions, localSettingsPath, silent = false) {
+    // Backup existing settings
+    if (await fs.pathExists(localSettingsPath)) {
+        await fs.copy(localSettingsPath, localSettingsPath + '.bak', { overwrite: true });
+        if (!silent)
+            p.log.info(`Backed up settings to ${color.dim(localSettingsPath + '.bak')}`);
+    }
+    let settingsJson = await fs.readFile(repoSettings, 'utf-8');
+    // Merge auto_install_extensions from index.json into settings
+    if (await fs.pathExists(repoExtensions)) {
+        try {
+            const indexJson = (await fs.readJson(repoExtensions));
+            const extensionIds = Object.keys(indexJson.extensions ?? {}).filter((id) => !indexJson.extensions[id]?.dev);
+            if (extensionIds.length > 0) {
+                const stripped = settingsJson.replace(/\/\/[^\n]*/g, '');
+                let settingsObj = {};
+                try {
+                    settingsObj = JSON.parse(stripped);
+                }
+                catch {
+                    if (!silent)
+                        p.log.warn(color.yellow('Could not parse settings.json — skipping extension merge.'));
+                }
+                const autoInstall = {};
+                for (const id of extensionIds) {
+                    autoInstall[id] = true;
+                }
+                settingsObj['auto_install_extensions'] = autoInstall;
+                settingsJson = JSON.stringify(settingsObj, null, 4);
+            }
+        }
+        catch {
+            if (!silent)
+                p.log.warn(color.yellow('Could not parse extensions/index.json — skipping extension merge.'));
+        }
+    }
+    await fs.ensureDir(path.dirname(localSettingsPath));
+    await fs.writeFile(localSettingsPath, settingsJson, 'utf-8');
+}
+// zedx sync init
+export async function syncInit() {
+    p.intro(color.bold('zedx sync init'));
+    const repo = await p.text({
+        message: 'GitHub repo URL (SSH or HTTPS)',
+        placeholder: 'https://github.com/you/zed-config.git',
+        validate: (v) => {
+            if (!v.trim())
+                return 'Repo URL is required';
+            if (!v.startsWith('https://') && !v.startsWith('git@')) {
+                return 'Must be a valid HTTPS or SSH git URL';
+            }
+        }
+    });
+    if (p.isCancel(repo)) {
+        p.cancel('Cancelled.');
+        process.exit(0);
+    }
+    const branch = await p.text({
+        message: 'Branch name',
+        placeholder: 'main',
+        defaultValue: 'main'
+    });
+    if (p.isCancel(branch)) {
+        p.cancel('Cancelled.');
+        process.exit(0);
+    }
+    const spinner = p.spinner();
+    spinner.start('Verifying repo is reachable...');
+    try {
+        const git = simpleGit();
+        await git.listRemote(['--heads', repo]);
+        spinner.stop('Repo verified.');
+    }
+    catch {
+        spinner.stop(color.yellow('Could not verify repo (may be empty or private — continuing anyway).'));
+    }
+    const config = {
+        syncRepo: repo.trim(),
+        branch: (branch || 'main').trim()
+    };
+    await writeSyncConfig(config);
+    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
+export async function runSync(opts = {}) {
+    const { silent = false } = opts;
+    // In silent mode (daemon/watch), route all UI through plain console.log
+    // Interactive conflict prompts fall back to "local wins".
+    const log = {
+        info: (msg) => {
+            if (!silent)
+                p.log.info(msg);
+        },
+        warn: (msg) => {
+            if (!silent)
+                p.log.warn(msg);
+            else
+                console.error(`[zedx] warn: ${msg}`);
+        },
+        success: (msg) => {
+            if (!silent)
+                p.log.success(msg);
+        }
+    };
+    if (!silent)
+        p.intro(color.bold('zedx sync'));
+    const config = await requireSyncConfig();
+    const zedPaths = resolveZedPaths();
+    // Spinner shim: in silent mode just log to stderr so daemons can capture it
+    const spinner = silent
+        ? {
+            start: (m) => console.error(`[zedx] ${m}`),
+            stop: (m) => console.error(`[zedx] ${m}`)
+        }
+        : p.spinner();
+    await withTempDir(async (tmp) => {
+        // 1. Clone the remote repo
+        const git = simpleGit(tmp);
+        let remoteExists = true;
+        spinner.start(`Fetching ${config.syncRepo}...`);
+        try {
+            await git.clone(config.syncRepo, tmp, ['--depth', '1', '--branch', config.branch]);
+            spinner.stop('Remote fetched.');
+        }
+        catch {
+            remoteExists = false;
+            spinner.stop('Remote is empty or branch not found — will push fresh.');
+            await git.init();
+            await git.addRemote('origin', config.syncRepo);
+        }
+        // 2. Determine what changed for each file
+        const lastSync = config.lastSync ? new Date(config.lastSync) : null;
+        const files = [
+            {
+                repoPath: path.join(tmp, 'settings.json'),
+                localPath: zedPaths.settings,
+                label: 'settings.json'
+            },
+            {
+                repoPath: path.join(tmp, 'extensions', 'index.json'),
+                localPath: zedPaths.extensions,
+                label: 'extensions/index.json'
+            }
+        ];
+        let anyChanges = false;
+        for (const file of files) {
+            const localExists = await fs.pathExists(file.localPath);
+            const remoteFileExists = remoteExists && (await fs.pathExists(file.repoPath));
+            // Both missing — skip
+            if (!localExists && !remoteFileExists) {
+                log.warn(`${file.label}: not found locally or remotely — skipping.`);
+                continue;
+            }
+            // Remote doesn't have it yet — push local
+            if (localExists && !remoteFileExists) {
+                log.info(`${file.label}: ${color.green('pushing')} (not in remote yet)`);
+                await fs.ensureDir(path.dirname(file.repoPath));
+                await fs.copy(file.localPath, file.repoPath, { overwrite: true });
+                anyChanges = true;
+                continue;
+            }
+            // Local doesn't have it — pull remote
+            if (!localExists && remoteFileExists) {
+                log.info(`${file.label}: ${color.cyan('pulling')} (not found locally)`);
+                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 });
+                }
+                continue;
+            }
+            // Both exist — compare content
+            const localContent = await fs.readFile(file.localPath, 'utf-8');
+            const remoteContent = await fs.readFile(file.repoPath, 'utf-8');
+            if (localContent === remoteContent) {
+                log.success(`${file.label}: ${color.dim('already in sync')}`);
+                continue;
+            }
+            // Detect which side changed since last sync via mtime
+            const localMtime = (await fs.stat(file.localPath)).mtime;
+            const remoteMtime = remoteFileExists ? (await fs.stat(file.repoPath)).mtime : new Date(0);
+            const localChanged = !lastSync || localMtime > lastSync;
+            const remoteChanged = !lastSync || remoteMtime > lastSync;
+            if (localChanged && !remoteChanged) {
+                // Only local changed → push
+                log.info(`${file.label}: ${color.green('pushing')} (local is newer)`);
+                await fs.ensureDir(path.dirname(file.repoPath));
+                await fs.copy(file.localPath, file.repoPath, { overwrite: true });
+                anyChanges = true;
+            }
+            else if (remoteChanged && !localChanged) {
+                // Only remote changed → pull
+                log.info(`${file.label}: ${color.cyan('pulling')} (remote is newer)`);
+                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 });
+                }
+            }
+            else {
+                // Both changed
+                if (silent) {
+                    // Daemon can't prompt — local wins, will be pushed
+                    log.warn(`${file.label}: conflict detected in unattended mode — keeping local.`);
+                    await fs.ensureDir(path.dirname(file.repoPath));
+                    await fs.copy(file.localPath, file.repoPath, { overwrite: true });
+                    anyChanges = true;
+                }
+                else {
+                    p.log.warn(color.yellow(`${file.label}: both local and remote changed.`));
+                    const choice = await p.select({
+                        message: `Which version of ${color.bold(file.label)} should win?`,
+                        options: [
+                            {
+                                value: 'local',
+                                label: 'Keep local',
+                                hint: `modified ${localMtime.toLocaleString()}`
+                            },
+                            {
+                                value: 'remote',
+                                label: 'Use remote',
+                                hint: `modified ${remoteMtime.toLocaleString()}`
+                            }
+                        ]
+                    });
+                    if (p.isCancel(choice)) {
+                        p.cancel('Cancelled.');
+                        process.exit(0);
+                    }
+                    if (choice === 'local') {
+                        p.log.info(`${file.label}: ${color.green('keeping local, will push')}`);
+                        await fs.ensureDir(path.dirname(file.repoPath));
+                        await fs.copy(file.localPath, file.repoPath, { overwrite: true });
+                        anyChanges = true;
+                    }
+                    else {
+                        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 });
+                        }
+                    }
+                }
+            }
+        }
+        // 3. Commit + push if any local files were written to the repo
+        if (anyChanges) {
+            spinner.start('Pushing changes to remote...');
+            await git.add(['settings.json', path.join('extensions', 'index.json')]);
+            const status = await git.status();
+            if (status.staged.length > 0) {
+                const timestamp = new Date().toISOString();
+                await git.commit(`sync: ${timestamp}`);
+                try {
+                    await git.push('origin', config.branch, ['--set-upstream']);
+                }
+                catch {
+                    await git.push('origin', config.branch);
+                }
+                spinner.stop('Pushed.');
+            }
+            else {
+                spinner.stop('Nothing staged to push.');
+            }
+        }
+    });
+    // 4. Save last sync timestamp
+    await writeSyncConfig({ ...config, lastSync: new Date().toISOString() });
+    if (!silent)
+        p.outro(`${color.green('✓')} Sync complete.`);
+}

package/dist/types/index.d.ts

@@ -1,4 +1,12 @@
 export type ExtensionType = 'theme' | 'language';
+export interface ZedPaths {
+    settings: string;
+    extensions: string;
+}
+export interface SyncConfig {
+    syncRepo: string;
+    branch: string;
+}
 export type License = 'Apache-2.0' | 'BSD-2-Clause' | 'BSD-3-Clause' | 'GPL-3.0' | 'LGPL-3.0' | 'MIT' | 'Zlib';
 export interface ExtensionOptions {
     name: string;

package/dist/zed-paths.d.ts

@@ -0,0 +1,2 @@
+import type { ZedPaths } from './types/index.js';
+export declare function resolveZedPaths(): ZedPaths;

package/dist/zed-paths.js

@@ -0,0 +1,30 @@
+import os from 'os';
+import path from 'path';
+export function resolveZedPaths() {
+    const home = os.homedir();
+    const platform = process.platform;
+    if (platform === 'darwin') {
+        return {
+            settings: path.join(home, '.config', 'zed', 'settings.json'),
+            extensions: path.join(home, 'Library', 'Application Support', 'Zed', 'extensions', 'index.json'),
+        };
+    }
+    if (platform === 'linux') {
+        const xdgData = process.env.FLATPAK_XDG_DATA_HOME ||
+            process.env.XDG_DATA_HOME ||
+            path.join(home, '.local', 'share');
+        return {
+            settings: path.join(home, '.config', 'zed', 'settings.json'),
+            extensions: path.join(xdgData, 'zed', 'extensions', 'index.json'),
+        };
+    }
+    if (platform === 'win32') {
+        const appData = process.env.APPDATA || path.join(home, 'AppData', 'Roaming');
+        const localAppData = process.env.LOCALAPPDATA || path.join(home, 'AppData', 'Local');
+        return {
+            settings: path.join(appData, 'Zed', 'settings.json'),
+            extensions: path.join(localAppData, 'Zed', 'extensions', 'index.json'),
+        };
+    }
+    throw new Error(`Unsupported platform: ${platform}`);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "zedx",
-	"version": "0.3.1",
+	"version": "0.5.0",
 	"description": "Boilerplate generator for Zed Edittor extensions.",
 	"type": "module",
 	"main": "dist/index.js",
@@ -47,7 +47,8 @@
 		"commander": "^14.0.3",
 		"ejs": "^4.0.1",
 		"fs-extra": "^11.3.3",
-		"picocolors": "^1.1.1"
+		"picocolors": "^1.1.1",
+		"simple-git": "^3.33.0"
 	},
 	"packageManager": "pnpm@10.30.0+sha512.2b5753de015d480eeb88f5b5b61e0051f05b4301808a82ec8b840c9d2adf7748eb352c83f5c1593ca703ff1017295bc3fdd3119abb9686efc96b9fcb18200937"
 }