@zpress/cli 0.2.1 → 0.3.0

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.map((err)=>{
+                const path = err.path.join('.');
+                return 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();
         }
         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.1",
+    version: "0.3.0",
     description: 'CLI for building and serving documentation',
     commands: {
         sync: syncCommand,

package/dist/watcher.mjs

@@ -18,31 +18,43 @@ const MARKDOWN_EXTENSIONS = [
     '.md',
     '.mdx'
 ];
+const MAX_DISPLAY_PATHS = 3;
 function isMarkdownFile(filePath) {
     return MARKDOWN_EXTENSIONS.some((ext)=>filePath.endsWith(ext));
 }
-function createWatcher(initialConfig, paths) {
+function nearestExistingAncestor(targetPath, fallbackRoot) {
+    let current = targetPath;
+    if (existsSync(current)) return current;
+    while(current !== node_path.dirname(current)){
+        current = node_path.dirname(current);
+        if (existsSync(current)) return current;
+    }
+    return fallbackRoot;
+}
+function createWatcher(initialConfig, paths, onConfigReload) {
     const { repoRoot } = paths;
     const configFiles = CONFIG_EXTENSIONS.map((ext)=>node_path.resolve(repoRoot, `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 [];
-        })(),
+    const contentPaths = extractWatchPaths(config.sections, repoRoot).map((p)=>nearestExistingAncestor(p, repoRoot));
+    const initialWatchPaths = [
+        ...contentPaths,
+        nearestExistingAncestor(planningDir, repoRoot),
         ...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(', ')}`);
+    const uniqueInitialPaths = [
+        ...new Set(initialWatchPaths)
+    ];
+    if (0 === uniqueInitialPaths.length) return void cliLogger.warn('No source paths to watch');
+    const relativePaths = uniqueInitialPaths.map((p)=>node_path.relative(repoRoot, p));
+    const pathsMessage = match(relativePaths.length <= MAX_DISPLAY_PATHS).with(true, ()=>relativePaths.join(', ')).otherwise(()=>`${relativePaths.slice(0, MAX_DISPLAY_PATHS).join(', ')} and ${relativePaths.length - MAX_DISPLAY_PATHS} more`);
+    cliLogger.info(`Watching ${uniqueInitialPaths.length} paths: ${pathsMessage}`);
     let syncing = false;
     let pendingReloadConfig = null;
     let consecutiveFailures = 0;
     const MAX_CONSECUTIVE_FAILURES = 5;
-    const watcher = watch(watchPaths, {
+    let currentWatchPaths = new Set(uniqueInitialPaths);
+    const watcher = watch(uniqueInitialPaths, {
         ignoreInitial: true,
         ignored: [
             '**/node_modules/**',
@@ -53,25 +65,67 @@ function createWatcher(initialConfig, paths) {
         awaitWriteFinish: {
             stabilityThreshold: 100,
             pollInterval: 50
-        }
+        },
+        depth: 99
     });
+    function updateWatchPaths(newConfig) {
+        const newContentPaths = extractWatchPaths(newConfig.sections, repoRoot);
+        const normalizedContentPaths = newContentPaths.map((p)=>nearestExistingAncestor(p, repoRoot));
+        const newWatchPaths = [
+            ...normalizedContentPaths,
+            nearestExistingAncestor(planningDir, repoRoot),
+            ...configFiles
+        ];
+        const newSet = new Set(newWatchPaths);
+        const toAdd = [
+            ...newSet
+        ].filter((p)=>!currentWatchPaths.has(p));
+        if (toAdd.length > 0) {
+            watcher.add(toAdd);
+            const relativeAdded = toAdd.map((p)=>node_path.relative(repoRoot, p));
+            const addedMessage = match(relativeAdded.length <= MAX_DISPLAY_PATHS).with(true, ()=>relativeAdded.join(', ')).otherwise(()=>`${relativeAdded.slice(0, MAX_DISPLAY_PATHS).join(', ')} and ${relativeAdded.length - MAX_DISPLAY_PATHS} more`);
+            cliLogger.info(`Added ${toAdd.length} watch paths: ${addedMessage}`);
+        }
+        const configFileSet = new Set(configFiles);
+        const toRemove = [
+            ...currentWatchPaths
+        ].filter((p)=>!newSet.has(p) && !configFileSet.has(p));
+        if (toRemove.length > 0) {
+            watcher.unwatch(toRemove);
+            const relativeRemoved = toRemove.map((p)=>node_path.relative(repoRoot, p));
+            const removedMessage = match(relativeRemoved.length <= MAX_DISPLAY_PATHS).with(true, ()=>relativeRemoved.join(', ')).otherwise(()=>`${relativeRemoved.slice(0, MAX_DISPLAY_PATHS).join(', ')} and ${relativeRemoved.length - MAX_DISPLAY_PATHS} more`);
+            cliLogger.info(`Removed ${toRemove.length} watch paths: ${removedMessage}`);
+        }
+        currentWatchPaths = newSet;
+    }
     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.map((err)=>{
+                        const pathStr = err.path.join('.');
+                        return cliLogger.error(`  ${pathStr}: ${err.message}`);
+                    });
+                    return;
+                }
                 config = newConfig;
                 cliLogger.info('Config reloaded');
+                updateWatchPaths(newConfig);
+                didReloadConfig = true;
             }
             await sync(config, {
                 paths
             });
             consecutiveFailures = 0;
+            if (didReloadConfig && onConfigReload) await onConfigReload(config);
         } catch (error) {
             consecutiveFailures += 1;
             const errorMessage = (()=>{

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zpress/cli",
-  "version": "0.2.1",
+  "version": "0.3.0",
   "description": "CLI for building and serving zpress documentation sites",
   "keywords": [
     "cli",
@@ -40,8 +40,8 @@
     "es-toolkit": "^1.45.1",
     "ts-pattern": "^5.9.0",
     "zod": "^4.3.6",
-    "@zpress/core": "0.5.0",
-    "@zpress/ui": "0.4.0"
+    "@zpress/core": "0.6.0",
+    "@zpress/ui": "0.5.0"
   },
   "devDependencies": {
     "@rslib/core": "^0.20.0",