@zpress/cli 0.2.2 → 0.3.1

package/dist/index.mjs

@@ -12,18 +12,49 @@ import promises from "node:fs/promises";
 import node_fs from "node:fs";
 const DEFAULT_PORT = 6174;
 async function startDevServer(options) {
-    const rspressConfig = createRspressConfig(options);
-    await dev({
-        appDirectory: options.paths.repoRoot,
-        docDirectory: options.paths.contentDir,
-        config: rspressConfig,
-        configFilePath: '',
-        extraBuilderConfig: {
-            server: {
-                port: DEFAULT_PORT
-            }
+    const { paths } = options;
+    let serverInstance = null;
+    async function startServer(config) {
+        const rspressConfig = createRspressConfig({
+            config,
+            paths
+        });
+        try {
+            serverInstance = await dev({
+                appDirectory: paths.repoRoot,
+                docDirectory: paths.contentDir,
+                config: rspressConfig,
+                configFilePath: '',
+                extraBuilderConfig: {
+                    server: {
+                        port: DEFAULT_PORT
+                    }
+                }
+            });
+        } catch (error) {
+            const errorMessage = (()=>{
+                if (error instanceof Error) return error.message;
+                return String(error);
+            })();
+            process.stderr.write(`Dev server error: ${errorMessage}\n`);
+            process.exit(1);
         }
-    });
+    }
+    await startServer(options.config);
+    return async (newConfig)=>{
+        process.stdout.write('\n🔄 Config changed — restarting dev server...\n');
+        if (serverInstance) try {
+            await serverInstance.close();
+        } catch (error) {
+            const errorMessage = (()=>{
+                if (error instanceof Error) return error.message;
+                return String(error);
+            })();
+            process.stderr.write(`Error closing server: ${errorMessage}\n`);
+        }
+        await startServer(newConfig);
+        process.stdout.write('✅ Dev server restarted\n\n');
+    };
 }
 async function buildSite(options) {
     const rspressConfig = createRspressConfig(options);
@@ -297,6 +328,10 @@ const buildCommand = command({
         const [configErr, config] = await loadConfig(paths.repoRoot);
         if (configErr) {
             ctx.logger.error(configErr.message);
+            if (configErr.errors && configErr.errors.length > 0) configErr.errors.map((err)=>{
+                const path = err.path.join('.');
+                return ctx.logger.error(`  ${path}: ${err.message}`);
+            });
             process.exit(1);
         }
         if (check) {
@@ -401,23 +436,27 @@ const devCommand = command({
         const [configErr, config] = await loadConfig(paths.repoRoot);
         if (configErr) {
             ctx.logger.error(configErr.message);
+            if (configErr.errors && configErr.errors.length > 0) configErr.errors.forEach((err)=>{
+                const path = err.path.join('.');
+                ctx.logger.error(`  ${path}: ${err.message}`);
+            });
             process.exit(1);
         }
         await sync(config, {
             paths,
             quiet
         });
+        const onConfigReload = await startDevServer({
+            config,
+            paths
+        });
         const { createWatcher } = await import("./watcher.mjs");
-        const watcher = createWatcher(config, paths);
+        const watcher = createWatcher(config, paths, onConfigReload);
         function cleanup() {
-            if (watcher) watcher.close();
+            watcher.close();
         }
         process.on('SIGINT', cleanup);
         process.on('SIGTERM', cleanup);
-        await startDevServer({
-            config,
-            paths
-        });
     }
 });
 function maybeLink(link) {
@@ -455,7 +494,7 @@ function toTree(entries) {
 }
 function buildDumpEntry(entry) {
     return {
-        text: entry.text,
+        text: entry.title,
         ...maybeLink(entry.link),
         ...maybeCollapsible(entry.collapsible),
         ...maybeHidden(entry.hidden),
@@ -470,6 +509,10 @@ const dumpCommand = command({
         const [configErr, config] = await loadConfig(paths.repoRoot);
         if (configErr) {
             ctx.logger.error(configErr.message);
+            if (configErr.errors && configErr.errors.length > 0) configErr.errors.map((err)=>{
+                const path = err.path.join('.');
+                return ctx.logger.error(`  ${path}: ${err.message}`);
+            });
             process.exit(1);
         }
         const previousManifest = await loadManifest(paths.contentDir);
@@ -508,6 +551,10 @@ const generateCommand = command({
         const [configErr, config] = await loadConfig(paths.repoRoot);
         if (configErr) {
             ctx.logger.error(configErr.message);
+            if (configErr.errors && configErr.errors.length > 0) configErr.errors.map((err)=>{
+                const path = err.path.join('.');
+                return ctx.logger.error(`  ${path}: ${err.message}`);
+            });
             process.exit(1);
         }
         const assetConfig = buildAssetConfig(config);
@@ -544,6 +591,10 @@ const serveCommand = command({
         const [configErr, config] = await loadConfig(paths.repoRoot);
         if (configErr) {
             ctx.logger.error(configErr.message);
+            if (configErr.errors && configErr.errors.length > 0) configErr.errors.map((err)=>{
+                const path = err.path.join('.');
+                return ctx.logger.error(`  ${path}: ${err.message}`);
+            });
             process.exit(1);
         }
         if (ctx.args.open) setTimeout(()=>openBrowser(`http://localhost:${DEFAULT_PORT}`), 2000);
@@ -644,6 +695,10 @@ const syncCommand = command({
         const [configErr, config] = await loadConfig(paths.repoRoot);
         if (configErr) {
             ctx.logger.error(configErr.message);
+            if (configErr.errors && configErr.errors.length > 0) configErr.errors.map((err)=>{
+                const path = err.path.join('.');
+                return ctx.logger.error(`  ${path}: ${err.message}`);
+            });
             process.exit(1);
         }
         await sync(config, {
@@ -655,7 +710,7 @@ const syncCommand = command({
 });
 await cli({
     name: 'zpress',
-    version: "0.2.2",
+    version: "0.3.1",
     description: 'CLI for building and serving documentation',
     commands: {
         sync: syncCommand,

package/dist/watcher.mjs

@@ -1,10 +1,8 @@
-import { existsSync } from "node:fs";
+import { watch } from "node:fs";
 import node_path from "node:path";
 import { cliLogger } from "@kidd-cli/core/logger";
-import { hasGlobChars, loadConfig, sync } from "@zpress/core";
-import { watch } from "chokidar";
+import { loadConfig, sync } from "@zpress/core";
 import { debounce } from "es-toolkit";
-import { match } from "ts-pattern";
 const CONFIG_EXTENSIONS = [
     '.ts',
     '.mts',
@@ -18,60 +16,56 @@ const MARKDOWN_EXTENSIONS = [
     '.md',
     '.mdx'
 ];
+const IGNORED_DIRS = new Set([
+    'node_modules',
+    '.git',
+    '.zpress',
+    'bundle',
+    'dist',
+    '.turbo'
+]);
 function isMarkdownFile(filePath) {
     return MARKDOWN_EXTENSIONS.some((ext)=>filePath.endsWith(ext));
 }
-function createWatcher(initialConfig, paths) {
+function isIgnored(filePath) {
+    return filePath.split(node_path.sep).some((segment)=>IGNORED_DIRS.has(segment));
+}
+function createWatcher(initialConfig, paths, onConfigReload) {
     const { repoRoot } = paths;
-    const configFiles = CONFIG_EXTENSIONS.map((ext)=>node_path.resolve(repoRoot, `zpress.config${ext}`));
+    const configFileNames = new Set(CONFIG_EXTENSIONS.map((ext)=>`zpress.config${ext}`));
     let config = initialConfig;
-    const planningDir = node_path.resolve(repoRoot, '.planning');
-    const watchPaths = [
-        ...extractWatchPaths(config.sections, repoRoot),
-        ...(()=>{
-            if (existsSync(planningDir)) return [
-                planningDir
-            ];
-            return [];
-        })(),
-        ...configFiles
-    ];
-    if (0 === watchPaths.length) return void cliLogger.warn('No source paths to watch');
-    cliLogger.info(`Watching ${watchPaths.length} paths: ${watchPaths.map((p)=>node_path.relative(repoRoot, p)).join(', ')}`);
+    cliLogger.info(`Watching ${repoRoot}`);
     let syncing = false;
     let pendingReloadConfig = null;
     let consecutiveFailures = 0;
     const MAX_CONSECUTIVE_FAILURES = 5;
-    const watcher = watch(watchPaths, {
-        ignoreInitial: true,
-        ignored: [
-            '**/node_modules/**',
-            '**/.git/**',
-            '**/.zpress/**',
-            '**/bundle/**'
-        ],
-        awaitWriteFinish: {
-            stabilityThreshold: 100,
-            pollInterval: 50
-        }
-    });
     async function triggerSync(reloadConfig) {
         if (syncing) {
             pendingReloadConfig = true === pendingReloadConfig || reloadConfig;
             return;
         }
         syncing = true;
+        let didReloadConfig = false;
         try {
             if (reloadConfig) {
                 const [configErr, newConfig] = await loadConfig(paths.repoRoot);
-                if (configErr) return void cliLogger.error(`Config reload failed: ${configErr.message}`);
+                if (configErr) {
+                    cliLogger.error(`Config reload failed: ${configErr.message}`);
+                    if (configErr.errors && configErr.errors.length > 0) configErr.errors.forEach((err)=>{
+                        const pathStr = err.path.join('.');
+                        cliLogger.error(`  ${pathStr}: ${err.message}`);
+                    });
+                    return;
+                }
                 config = newConfig;
                 cliLogger.info('Config reloaded');
+                didReloadConfig = true;
             }
             await sync(config, {
                 paths
             });
             consecutiveFailures = 0;
+            if (didReloadConfig && onConfigReload) await onConfigReload(config);
         } catch (error) {
             consecutiveFailures += 1;
             const errorMessage = (()=>{
@@ -94,60 +88,30 @@ function createWatcher(initialConfig, paths) {
     }
     const debouncedSync = debounce(()=>triggerSync(false), 150);
     const debouncedConfigSync = debounce(()=>triggerSync(true), 150);
-    const configFileSet = new Set(configFiles);
-    function isConfigFile(filePath) {
-        return configFileSet.has(node_path.resolve(filePath));
+    function isConfigFile(filename, filePath) {
+        if (!configFileNames.has(filename)) return false;
+        const dir = node_path.dirname(filePath);
+        return '.' === dir;
     }
-    watcher.on('change', (filePath)=>{
-        if (isConfigFile(filePath)) {
-            cliLogger.info(`Config changed: ${node_path.basename(filePath)}`);
+    const watcher = watch(repoRoot, {
+        recursive: true
+    }, (_event, filename)=>{
+        if (!filename) return;
+        if (isIgnored(filename)) return;
+        const basename = node_path.basename(filename);
+        if (isConfigFile(basename, filename)) {
+            cliLogger.info(`Config changed: ${basename}`);
             debouncedConfigSync();
             return;
         }
-        if (!isMarkdownFile(filePath)) return;
-        cliLogger.step(`Changed: ${node_path.relative(repoRoot, filePath)}`);
+        if (!isMarkdownFile(filename)) return;
+        cliLogger.step(`Changed: ${filename}`);
         debouncedSync();
     });
-    watcher.on('add', (filePath)=>{
-        if (!isMarkdownFile(filePath)) return;
-        cliLogger.step(`Added: ${node_path.relative(repoRoot, filePath)}`);
-        debouncedSync();
-    });
-    watcher.on('unlink', (filePath)=>{
-        if (!isMarkdownFile(filePath)) return;
-        cliLogger.step(`Removed: ${node_path.relative(repoRoot, filePath)}`);
-        debouncedSync();
-    });
-    return watcher;
-}
-function extractWatchPaths(entries, repoRoot) {
-    const dirs = new Set();
-    const files = new Set();
-    function walk(items) {
-        items.map((entry)=>{
-            if (entry.from) if (hasGlobChars(entry.from)) {
-                const [beforeGlob] = entry.from.split('*');
-                const dir = match(beforeGlob.endsWith('/')).with(true, ()=>beforeGlob.slice(0, -1)).otherwise(()=>node_path.dirname(beforeGlob));
-                dirs.add(node_path.resolve(repoRoot, dir));
-            } else files.add(node_path.resolve(repoRoot, entry.from));
-            if (entry.items) walk(entry.items);
-            return null;
-        });
-    }
-    walk(entries);
-    const sortedDirs = [
-        ...dirs
-    ].toSorted();
-    const dedupedDirs = sortedDirs.filter((dir, index)=>{
-        const previousDirs = sortedDirs.slice(0, index);
-        return !previousDirs.some((parent)=>dir.startsWith(`${parent}${node_path.sep}`));
-    });
-    const extraFiles = [
-        ...files
-    ].filter((file)=>!dedupedDirs.some((dir)=>file.startsWith(dir + node_path.sep)));
-    return [
-        ...dedupedDirs,
-        ...extraFiles
-    ];
+    return {
+        close () {
+            watcher.close();
+        }
+    };
 }
 export { createWatcher };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zpress/cli",
-  "version": "0.2.2",
+  "version": "0.3.1",
   "description": "CLI for building and serving zpress documentation sites",
   "keywords": [
     "cli",
@@ -36,12 +36,11 @@
   "dependencies": {
     "@kidd-cli/core": "^0.4.0",
     "@rspress/core": "^2.0.5",
-    "chokidar": "^5.0.0",
     "es-toolkit": "^1.45.1",
     "ts-pattern": "^5.9.0",
     "zod": "^4.3.6",
-    "@zpress/core": "0.5.0",
-    "@zpress/ui": "0.4.1"
+    "@zpress/core": "0.6.1",
+    "@zpress/ui": "0.5.1"
   },
   "devDependencies": {
     "@rslib/core": "^0.20.0",