zedx 0.4.0 → 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)
 
@@ -30,6 +30,12 @@ zedx check
 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/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/index.js

@@ -8,6 +8,8 @@ import { promptUser, promptThemeDetails, promptLanguageDetails } from './prompts
 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) {
@@ -76,6 +78,30 @@ async function main() {
         .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.4.0",
+	"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"
 }