dogsbay 0.2.0-beta.7 → 0.2.0-beta.8

package/dist/commands/site-dev.js

@@ -1,7 +1,7 @@
 /**
  * `dogsbay site dev` and `dogsbay site preview` — thin wrappers that
- * run `dogsbay site build` once, then hand control over to the Astro
- * CLI inside the site directory.
+ * run `dogsbay site build`, watch content for changes, and hand
+ * control over to the Astro CLI inside the site directory.
  *
  *   dev      → astro dev      (live HMR for already-built pages)
  *   preview  → astro build && astro preview
@@ -11,12 +11,16 @@
  * existing script) is *not* what runs here — we shell out to `astro`
  * directly so this works whether the user uses pnpm / npm / yarn.
  *
- * Content file-watching is deferred. Today, editing source markdown
- * requires re-running `dogsbay site build` manually; Astro's dev
- * server reloads when the generated `.astro` files change.
+ * `site dev` also installs a content watcher that re-runs
+ * `dogsbay site build` whenever a markdown / yaml / json file under
+ * any configured source path changes (or `dogsbay.config.yml`
+ * itself). Astro's own dev server then hot-reloads the regenerated
+ * `.astro` pages. Without this, NEW files in `content/` weren't
+ * picked up by site dev — only edits to existing files surfaced
+ * (because Astro's watcher only sees `astro/src/`).
  */
 import { spawn } from "node:child_process";
-import { existsSync } from "node:fs";
+import { existsSync, watch as fsWatch } from "node:fs";
 import { dirname, join, resolve } from "node:path";
 import pc from "picocolors";
 import { findConfig, loadConfig, resolveOutputDir } from "../config/index.js";
@@ -63,18 +67,26 @@ function runPackageManagerInstall(pm, cwd) {
     });
 }
 export async function siteDev(cwd, options, runner = defaultRunner) {
-    const siteRoot = await prepareForAstro(cwd, options);
-    const code = await runner(siteRoot, ["dev"]);
-    process.exit(code);
+    const { siteRoot, outputDir } = await prepareForAstro(cwd, options);
+    const stopWatcher = startContentWatcher(siteRoot, outputDir, options);
+    try {
+        const code = await runner(outputDir, ["dev"]);
+        stopWatcher();
+        process.exit(code);
+    }
+    catch (err) {
+        stopWatcher();
+        throw err;
+    }
 }
 export async function sitePreview(cwd, options, runner = defaultRunner) {
-    const siteRoot = await prepareForAstro(cwd, options);
+    const { outputDir } = await prepareForAstro(cwd, options);
     // Two-step: produce dist/ then serve it. Each spawn is independent
     // so we can still surface its exit code cleanly.
-    const buildCode = await runner(siteRoot, ["build"]);
+    const buildCode = await runner(outputDir, ["build"]);
     if (buildCode !== 0)
         process.exit(buildCode);
-    const previewCode = await runner(siteRoot, ["preview"]);
+    const previewCode = await runner(outputDir, ["preview"]);
     process.exit(previewCode);
 }
 async function prepareForAstro(cwd, options) {
@@ -117,7 +129,149 @@ async function prepareForAstro(cwd, options) {
             publish: options.full === true,
         });
     }
-    return outputDir;
+    return { siteRoot, outputDir };
+}
+/**
+ * Watch the project's content paths + config file, and re-run
+ * `dogsbay site build` whenever something changes. Astro's own
+ * watcher then picks up the regenerated `astro/src/pages/*.astro`
+ * files and hot-reloads.
+ *
+ * Returns a cleanup fn that closes all the watchers.
+ *
+ * Debounces aggressively — many editors fire 3-5 fs events per save
+ * (write + rename + close-write etc.), and a single Vim save bursts
+ * across multiple files. 300ms is the sweet spot: low enough that
+ * the user feels the rebuild as immediate, high enough to coalesce
+ * a save burst into one rebuild.
+ */
+function startContentWatcher(siteRoot, outputDir, options) {
+    // Re-load the config to know which paths to watch. We load it
+    // from disk on first event too (so config edits update the watch
+    // set on the fly).
+    let config = loadConfig(findOrFail(siteRoot, options.config));
+    // Track which paths we've armed a watcher on. fs.watch with
+    // recursive: true scoops up everything under each root.
+    const watchers = new Set();
+    const armed = new Set();
+    const arm = (root) => {
+        if (armed.has(root))
+            return;
+        if (!existsSync(root))
+            return;
+        armed.add(root);
+        try {
+            const w = fsWatch(root, { recursive: true }, (_event, filename) => {
+                if (!filename)
+                    return;
+                const fname = filename.toString();
+                if (shouldIgnore(fname))
+                    return;
+                scheduleBuild();
+            });
+            watchers.add(w);
+        }
+        catch (err) {
+            console.error(pc.yellow(`  warn: could not watch ${root}: ${err.message}`));
+        }
+    };
+    // Always watch the config file itself (one level up — fs.watch on
+    // a single file works on macOS/Windows; on Linux some filesystems
+    // require watching the parent dir).
+    arm(siteRoot);
+    // Watch each local source path declared in the config.
+    for (const source of config.content?.sources ?? []) {
+        if (typeof source.path === "string") {
+            const abs = resolve(siteRoot, source.path);
+            arm(abs);
+        }
+    }
+    // Debounced rebuild loop. If a build is in flight when a new
+    // event arrives, mark dirty + rebuild after the current one
+    // finishes. Avoids overlapping builds racing on the same files.
+    let timer = null;
+    let building = false;
+    let dirty = false;
+    const scheduleBuild = () => {
+        dirty = true;
+        if (timer)
+            clearTimeout(timer);
+        timer = setTimeout(runBuild, 300);
+    };
+    const runBuild = async () => {
+        if (building)
+            return; // a build is in flight; the dirty flag handles re-run
+        if (!dirty)
+            return;
+        dirty = false;
+        building = true;
+        try {
+            console.log(pc.cyan("[dogsbay] content changed — rebuilding…"));
+            // Reload config to pick up dogsbay.config.yml edits.
+            config = loadConfig(findOrFail(siteRoot, options.config));
+            // Re-arm any newly-added source paths.
+            for (const source of config.content?.sources ?? []) {
+                if (typeof source.path === "string") {
+                    arm(resolve(siteRoot, source.path));
+                }
+            }
+            await siteBuild(siteRoot, {
+                includeDrafts: true,
+                publish: options.full === true,
+            });
+            console.log(pc.green("[dogsbay] rebuild complete"));
+        }
+        catch (err) {
+            console.error(pc.red(`[dogsbay] rebuild failed: ${err.message}`));
+        }
+        finally {
+            building = false;
+            // Coalesced changes during the build → run again.
+            if (dirty)
+                setImmediate(runBuild);
+        }
+    };
+    // Diagnostic: show what's being watched on startup.
+    console.log(pc.gray(`[dogsbay] watching ${armed.size} path${armed.size === 1 ? "" : "s"} for content changes`));
+    return () => {
+        if (timer)
+            clearTimeout(timer);
+        for (const w of watchers) {
+            try {
+                w.close();
+            }
+            catch { /* ignore */ }
+        }
+        watchers.clear();
+        armed.clear();
+    };
+}
+/**
+ * Heuristic: skip events on paths the user doesn't care about.
+ * Filters out the output dir (would loop), VCS metadata, OS junk,
+ * and editor swap files.
+ */
+function shouldIgnore(filename) {
+    if (filename.startsWith(".git/") || filename === ".git")
+        return true;
+    if (filename.startsWith("node_modules/"))
+        return true;
+    if (filename.startsWith("astro/"))
+        return true; // output dir — would loop
+    if (filename.startsWith("dist/"))
+        return true;
+    if (filename.startsWith(".dogsbay/"))
+        return true; // skill symlinks
+    if (filename.endsWith(".swp") || filename.endsWith(".swo"))
+        return true;
+    if (filename.endsWith("~"))
+        return true;
+    if (filename.endsWith(".DS_Store"))
+        return true;
+    return false;
+}
+function findOrFail(siteRoot, explicit) {
+    return resolveConfigPath(siteRoot, explicit);
 }
 function resolveConfigPath(startDir, explicit) {
     if (explicit) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dogsbay",
-  "version": "0.2.0-beta.7",
+  "version": "0.2.0-beta.8",
   "description": "CLI for Dogsbay — scaffold, build, and serve documentation sites with markdown / MkDocs / Obsidian / OpenAPI sources",
   "type": "module",
   "bin": {
@@ -31,14 +31,14 @@
     "picocolors": "^1.1.0",
     "prompts": "^2.4.2",
     "yaml": "^2.8.3",
-    "@dogsbay/format-mkdocs": "0.2.0-beta.7",
-    "@dogsbay/format-astro": "0.2.0-beta.7",
-    "@dogsbay/format-mdx": "0.2.0-beta.7",
-    "@dogsbay/format-obsidian": "0.2.0-beta.7",
-    "@dogsbay/format-starlight": "0.2.0-beta.7",
-    "@dogsbay/format-dogsbay-md": "0.2.0-beta.7",
-    "@dogsbay/format-openapi": "0.2.0-beta.7",
-    "@dogsbay/types": "0.2.0-beta.7"
+    "@dogsbay/format-mkdocs": "0.2.0-beta.8",
+    "@dogsbay/format-astro": "0.2.0-beta.8",
+    "@dogsbay/format-obsidian": "0.2.0-beta.8",
+    "@dogsbay/format-mdx": "0.2.0-beta.8",
+    "@dogsbay/format-starlight": "0.2.0-beta.8",
+    "@dogsbay/format-dogsbay-md": "0.2.0-beta.8",
+    "@dogsbay/format-openapi": "0.2.0-beta.8",
+    "@dogsbay/types": "0.2.0-beta.8"
   },
   "devDependencies": {
     "@types/node": "^22.0.0",