dogsbay 0.2.0-beta.1 → 0.2.0-beta.10

package/dist/commands/agent.js

@@ -0,0 +1,305 @@
+/**
+ * `dogsbay agent install` — wire skill discovery for an LLM agent
+ * (Claude Code, Cursor, Copilot, etc.).
+ *
+ * Bundled platform skills live at `<cli-install-dir>/skills/platform/*.md`.
+ * This command:
+ *   1. Resolves the bundled platform skills directory.
+ *   2. Symlinks them into `<project>/.dogsbay/skills/platform/`.
+ *   3. Creates `.dogsbay/skills/site/` (empty + README) and
+ *      `.dogsbay/skills/plugins/` (empty placeholder).
+ *   4. For each requested --agent, writes the per-agent discovery
+ *      path (`.claude/skills/dogsbay/`, `.cursor/rules/dogsbay/`).
+ *
+ * Re-running is idempotent — symlinks are recreated; existing
+ * site/ files are never touched.
+ *
+ * See plans/dogsbay-agent-skills.md for the four-tier ownership
+ * model and how this fits.
+ */
+import { existsSync, lstatSync, mkdirSync, readdirSync, symlinkSync, unlinkSync, writeFileSync, statSync, readlinkSync } from "node:fs";
+import { dirname, join, relative, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import pc from "picocolors";
+const SUPPORTED_AGENTS = ["claude", "cursor"];
+const AGENT_TARGETS = {
+    claude: {
+        name: "claude",
+        skillsDir: ".claude/skills",
+        label: "Claude Code",
+    },
+    cursor: {
+        name: "cursor",
+        skillsDir: ".cursor/rules",
+        label: "Cursor",
+    },
+};
+/**
+ * Prefix every Dogsbay-shipped skill so it doesn't collide with
+ * the user's own skills under the same agent's discovery path.
+ */
+const PLATFORM_PREFIX = "dogsbay-";
+const SITE_PREFIX = "dogsbay-site-";
+const PLUGIN_PREFIX = "dogsbay-plugin-";
+export async function agentInstall(cwd, options) {
+    const projectRoot = resolve(cwd || ".");
+    // Resolve the bundled platform-skills directory. We're running
+    // from <cli-install>/dist/commands/agent.js, so walk up to
+    // <cli-install>/skills/platform/.
+    const here = dirname(fileURLToPath(import.meta.url));
+    const platformSkills = resolve(here, "..", "..", "skills", "platform");
+    if (!existsSync(platformSkills)) {
+        console.error(pc.red(`Error: bundled platform skills not found at ${platformSkills}.`));
+        console.error(`       The dogsbay CLI install seems incomplete. Reinstall with`);
+        console.error(`       'npm install -g dogsbay@latest'.`);
+        process.exit(1);
+    }
+    // Pick the agents to install.
+    const agents = pickAgents(options);
+    if (agents.length === 0) {
+        printDetected(projectRoot);
+        return;
+    }
+    console.log(pc.cyan("→ Installing skill discovery"));
+    // 1. Always set up .dogsbay/skills/{platform,site,plugins}.
+    const dogsbayDir = join(projectRoot, ".dogsbay");
+    const skillsDir = join(dogsbayDir, "skills");
+    mkdirSync(skillsDir, { recursive: true });
+    const platformLink = join(skillsDir, "platform");
+    refreshSymlink(platformLink, platformSkills);
+    console.log(pc.green(`  ✓ ${relative(projectRoot, platformLink)} → bundled platform skills`));
+    const siteDir = join(skillsDir, "site");
+    if (!existsSync(siteDir)) {
+        mkdirSync(siteDir, { recursive: true });
+        writeFileSync(join(siteDir, "README.md"), `# Site skills
+
+This directory holds **site-specific** skills — your team's style
+guide, voice / tone, terminology, glossary, internal conventions.
+Anything an LLM should know that's specific to THIS site.
+
+Each skill is a single \`.md\` file with frontmatter:
+
+\`\`\`markdown
+---
+name: site:style-guide
+description: Our team's writing voice, terminology, and PR conventions.
+---
+
+# Style guide
+
+We use Oxford commas. Sentence-case headings. ...
+\`\`\`
+
+These skills are picked up automatically by any agent you've
+installed via \`dogsbay agent install --agent <name>\`.
+
+To override a platform skill (e.g. a different opinion on
+\`nav-file.md\`), put your version under \`overrides/<skill-name>.md\`.
+The agent loader checks overrides first.
+`);
+        console.log(pc.green(`  ✓ ${relative(projectRoot, siteDir)} created (empty + README)`));
+    }
+    else {
+        console.log(pc.gray(`  · ${relative(projectRoot, siteDir)} already exists (preserved)`));
+    }
+    const pluginsDir = join(skillsDir, "plugins");
+    if (!existsSync(pluginsDir)) {
+        mkdirSync(pluginsDir, { recursive: true });
+    }
+    // 2. Per-agent discovery — symlink each skill INDIVIDUALLY at
+    // the top level of the agent's skills dir. Claude Code (and
+    // similar harnesses) discover skills as direct children of
+    // .claude/skills/, each containing a SKILL.md. Nested
+    // .claude/skills/dogsbay/platform/<skill>/ doesn't get scanned.
+    for (const agent of agents) {
+        const target = AGENT_TARGETS[agent];
+        const agentSkillsDir = join(projectRoot, target.skillsDir);
+        mkdirSync(agentSkillsDir, { recursive: true });
+        let installed = 0;
+        let removed = 0;
+        // Platform skills: dogsbay-<name>
+        for (const entry of readSkillDirs(join(skillsDir, "platform"))) {
+            const dest = join(agentSkillsDir, `${PLATFORM_PREFIX}${entry.name}`);
+            refreshSymlink(dest, entry.path);
+            installed++;
+        }
+        // Site skills: dogsbay-site-<name> (skipping overrides/ and the README)
+        for (const entry of readSkillDirs(join(skillsDir, "site"))) {
+            if (entry.name === "overrides")
+                continue;
+            const dest = join(agentSkillsDir, `${SITE_PREFIX}${entry.name}`);
+            refreshSymlink(dest, entry.path);
+            installed++;
+        }
+        // Plugin skills: dogsbay-plugin-<name>
+        for (const entry of readSkillDirs(join(skillsDir, "plugins"))) {
+            const dest = join(agentSkillsDir, `${PLUGIN_PREFIX}${entry.name}`);
+            refreshSymlink(dest, entry.path);
+            installed++;
+        }
+        // Sweep any stale dogsbay-* symlinks whose target no longer
+        // exists (e.g. user uninstalled a plugin, or a platform skill
+        // was renamed across CLI versions).
+        if (existsSync(agentSkillsDir)) {
+            for (const name of readdirSync(agentSkillsDir)) {
+                if (!name.startsWith("dogsbay-"))
+                    continue;
+                const path = join(agentSkillsDir, name);
+                if (isBrokenSymlink(path)) {
+                    try {
+                        unlinkSync(path);
+                        removed++;
+                    }
+                    catch { /* ignore */ }
+                }
+            }
+        }
+        console.log(pc.green(`  ✓ ${target.label}: ${installed} skills under ${target.skillsDir}/`));
+        if (removed > 0) {
+            console.log(pc.gray(`    (cleaned up ${removed} stale symlink${removed === 1 ? "" : "s"})`));
+        }
+    }
+    console.log("");
+    console.log(pc.cyan("Next:"));
+    console.log("  Open your editor — the agent should now see Dogsbay platform skills");
+    console.log("  on next prompt.");
+    console.log("");
+    console.log("  Add team-specific skills to .dogsbay/skills/site/.");
+    console.log("  Override a platform skill with .dogsbay/skills/site/overrides/<name>.md.");
+}
+/**
+ * Decide which agents to set up. Priority:
+ *   --all → every supported agent
+ *   --agent claude,cursor → exactly that list
+ *   neither → return [], caller prints detected agents and exits
+ */
+function pickAgents(options) {
+    if (options.all)
+        return [...SUPPORTED_AGENTS];
+    if (options.agent) {
+        const requested = options.agent.split(",").map((a) => a.trim().toLowerCase());
+        const valid = [];
+        for (const r of requested) {
+            if (SUPPORTED_AGENTS.includes(r)) {
+                valid.push(r);
+            }
+            else {
+                console.error(pc.yellow(`  warn: unknown agent "${r}" (supported: ${SUPPORTED_AGENTS.join(", ")})`));
+            }
+        }
+        return valid;
+    }
+    return [];
+}
+/**
+ * When called without --agent or --all, just probe the project
+ * for known agent-config dirs and suggest commands.
+ */
+function printDetected(projectRoot) {
+    const detected = [];
+    if (existsSync(join(projectRoot, ".claude"))) {
+        detected.push({ agent: "claude", signal: ".claude/" });
+    }
+    if (existsSync(join(projectRoot, ".cursor")) ||
+        existsSync(join(projectRoot, ".cursorrules"))) {
+        detected.push({ agent: "cursor", signal: ".cursor/ or .cursorrules" });
+    }
+    console.log(pc.cyan("Dogsbay agent install"));
+    console.log("");
+    console.log("Wires Dogsbay platform skills into the discovery path of an");
+    console.log("LLM agent so it picks them up on every prompt.");
+    console.log("");
+    if (detected.length > 0) {
+        console.log(pc.green("Detected in this project:"));
+        for (const d of detected) {
+            console.log(`  ${d.agent.padEnd(8)} (${d.signal})`);
+        }
+        console.log("");
+        console.log("Run:");
+        for (const d of detected) {
+            console.log(`  dogsbay agent install --agent ${d.agent}`);
+        }
+        console.log("  dogsbay agent install --all      # set up every detected agent");
+    }
+    else {
+        console.log(pc.yellow("No supported agent configs detected in this project."));
+        console.log("");
+        console.log("Run:");
+        console.log("  dogsbay agent install --agent claude");
+        console.log("  dogsbay agent install --agent cursor");
+        console.log("  dogsbay agent install --all");
+    }
+    console.log("");
+    console.log(`Supported agents: ${SUPPORTED_AGENTS.join(", ")}`);
+}
+/**
+ * List each subdirectory of `dir` that looks like a skill — i.e.
+ * contains a SKILL.md file. Returns an empty array if `dir`
+ * doesn't exist or has no skill subdirs.
+ */
+function readSkillDirs(dir) {
+    if (!existsSync(dir))
+        return [];
+    const out = [];
+    for (const name of readdirSync(dir)) {
+        if (name.startsWith("."))
+            continue;
+        const path = join(dir, name);
+        let isDir = false;
+        try {
+            isDir = statSync(path).isDirectory();
+        }
+        catch {
+            isDir = false;
+        }
+        if (!isDir)
+            continue;
+        if (!existsSync(join(path, "SKILL.md")))
+            continue;
+        out.push({ name, path });
+    }
+    return out;
+}
+/**
+ * Replace any existing entry at `linkPath` with a fresh symlink
+ * pointing at `target`. Idempotent: if the link already points at
+ * the right place, leaves it alone.
+ */
+function refreshSymlink(linkPath, target) {
+    if (existsSync(linkPath) || isBrokenSymlink(linkPath)) {
+        try {
+            const current = readlinkSync(linkPath);
+            const resolved = resolve(dirname(linkPath), current);
+            if (resolved === target)
+                return; // already correct
+        }
+        catch {
+            // not a symlink
+        }
+        try {
+            unlinkSync(linkPath);
+        }
+        catch {
+            // ignore
+        }
+    }
+    symlinkSync(target, linkPath, "dir");
+}
+/**
+ * True only when `p` IS a symlink AND its target doesn't exist.
+ * Used by the cleanup pass to remove links pointing at gone paths
+ * (e.g. an uninstalled plugin or a renamed platform skill across
+ * CLI versions).
+ */
+function isBrokenSymlink(p) {
+    try {
+        const lst = lstatSync(p);
+        if (!lst.isSymbolicLink())
+            return false;
+    }
+    catch {
+        return false;
+    }
+    // It's a symlink. existsSync follows the link; false → target gone.
+    return !existsSync(p);
+}

package/dist/commands/site-build.js

@@ -66,11 +66,21 @@ export async function siteBuild(cwd, options) {
         console.error(`       Run \`dogsbay site init ${siteRoot}\` first.`);
         process.exit(1);
     }
-    // 5. Filter to primary sources (default) or load full matrix
-    // (--publish). Primary-only is the fast path local iteration
-    // and CI lint jobs use; --publish builds everything for the
-    // deploy job. See plans/multi-source-content.md → "Build modes".
-    const mode = options.publish ? "all" : "primary";
+    // 5. Default to publish mode (every declared source builds) so
+    // multi-locale / multi-version / multi-namespace sites Just Work
+    // when the writer runs `dogsbay site build`. Use --primary-only
+    // for fast-iteration CI jobs that don't need the full matrix
+    // (rare). The `--publish` flag is kept as a deprecated no-op for
+    // older scripts.
+    //
+    // Previous default was "primary-only" — silently dropped non-
+    // primary sources from production builds. With i18n and version
+    // axes, that meant declaring `locales:` resulted in only the
+    // English source shipping, surprising every writer who ran
+    // `dogsbay site build` after declaring fr. Inverted to match the
+    // strongest signal: declaring more sources means you want them
+    // all. See plans/beta-launch-followups.md.
+    const mode = options.primaryOnly ? "primary" : "all";
     const originalSources = config.content.sources;
     const totalSources = originalSources.length;
     const { sources: activeSources, indices: activeIndices } = filterSourcesForMode(originalSources, mode);
@@ -231,21 +241,22 @@ export async function siteBuild(cwd, options) {
         console.warn(`  Copy markdown + View as markdown work without it.`);
     }
     console.log(pc.green(`\nDone! Built ${generated} pages into ${outputDir}`));
-    // When the writer has marked some sources as primary and we
-    // built only those, surface the --publish hint. Skip the hint
-    // for plain single-source builds and for full --publish runs
-    // — both already build everything.
+    // When the writer ran with --primary-only and we filtered the
+    // matrix, surface a hint that drops them back to the default.
+    // Skip for single-source / full-matrix builds — both already
+    // built everything.
     if (mode === "primary" && primaryModeFiltersAnything(originalSources)) {
         const skipped = totalSources - activeIndices.length;
         console.log("");
-        console.log(pc.dim(`Built ${activeIndices.length} primary source(s); ` +
-            `${skipped} non-primary skipped. ` +
-            `Run \`dogsbay site build --publish\` for the full matrix.`));
+        console.log(pc.dim(`--primary-only built ${activeIndices.length} of ${totalSources} ` +
+            `sources; ${skipped} non-primary skipped. ` +
+            `Drop --primary-only to build the full matrix.`));
     }
     console.log("");
     console.log(pc.cyan("Next:"));
-    console.log("  npm run build              # Astro build → dist/");
-    console.log("  dogsbay site dev           # local preview with hot reload");
+    console.log("  dogsbay site dev           # live preview at http://localhost:4321");
+    console.log("  dogsbay site preview       # production build → dist/ + serve");
+    console.log("  dogsbay site check         # run audit rules");
 }
 // ─── Helpers ─────────────────────────────────────────────────────────────
 function resolveConfigPath(startDir, explicit) {

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,14 +11,19 @@
  * 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 { dirname, join, resolve } from "node:path";
 import pc from "picocolors";
+import chokidar from "chokidar";
 import { findConfig, loadConfig, resolveOutputDir } from "../config/index.js";
 import { siteBuild } from "./site-build.js";
 const defaultRunner = (siteRoot, args) => new Promise((resolve) => {
@@ -32,19 +37,57 @@ const defaultRunner = (siteRoot, args) => new Promise((resolve) => {
         resolve(1);
     });
 });
+/**
+ * Pick the first available package manager from a preference list.
+ * Defaults to pnpm (matches the dogsbay tooling chain); falls back
+ * to npm so machines without pnpm don't dead-end.
+ */
+function pickPackageManager() {
+    const onPath = (cmd) => {
+        try {
+            const { execSync } = require("node:child_process");
+            execSync(`command -v ${cmd}`, { stdio: "ignore" });
+            return true;
+        }
+        catch {
+            return false;
+        }
+    };
+    if (onPath("pnpm"))
+        return "pnpm";
+    return "npm";
+}
+function runPackageManagerInstall(pm, cwd) {
+    return new Promise((resolve) => {
+        const child = spawn(pm, ["install"], { cwd, stdio: "inherit" });
+        child.on("exit", (code) => resolve(code ?? 0));
+        child.on("error", (err) => {
+            console.error(pc.red(`Error: failed to spawn ${pm}: ${err.message}`));
+            resolve(1);
+        });
+    });
+}
 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) {
@@ -61,9 +104,18 @@ async function prepareForAstro(cwd, options) {
         process.exit(1);
     }
     if (!existsSync(join(outputDir, "node_modules"))) {
-        console.error(pc.red(`Error: dependencies not installed at ${outputDir}.`));
-        console.error(`       Run \`pnpm install\` (or \`npm install\`) in ${outputDir}.`);
-        process.exit(1);
+        // First-run: install scaffolded site's deps automatically. Picks
+        // pnpm if available, otherwise npm. Friendly users shouldn't have
+        // to know this is a separate project under the hood — the
+        // dogsbay command should Just Work the first time.
+        const pm = pickPackageManager();
+        console.log(pc.cyan(`Installing scaffolded site deps (one-time, ~30s) — using ${pm}...`));
+        const installCode = await runPackageManagerInstall(pm, outputDir);
+        if (installCode !== 0) {
+            console.error(pc.red(`Error: ${pm} install failed in ${outputDir} (exit ${installCode}).`));
+            console.error(`       Try running \`${pm} install\` manually in that directory.`);
+            process.exit(installCode);
+        }
     }
     // Refresh content / config-derived / agent-readiness files before
     // handing off to Astro. Skip with --no-build for fast iteration when
@@ -71,14 +123,140 @@ async function prepareForAstro(cwd, options) {
     if (!options.noBuild) {
         // Drafts visible during local preview — site dev is the writer's
         // iteration loop. Production `dogsbay site build` filters drafts.
-        // Default mode is primary-only; `--full` opts into the publish
-        // matrix for previewing switcher chrome.
+        // site dev defaults to primary-only for fast iteration; --full
+        // opts into the publish matrix for previewing switcher chrome.
+        // (Production `dogsbay site build` defaults to full matrix; only
+        // site dev / preview default to primary-only.)
         await siteBuild(siteRoot, {
             includeDrafts: true,
-            publish: options.full === true,
+            primaryOnly: 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));
+    // chokidar (vs Node's fs.watch) — fs.watch with `recursive: true`
+    // on Linux drops events from atomic-replace editor saves (Vim,
+    // VS Code, Helix all write tmp + rename), so nav.yml edits never
+    // surfaced as [dogsbay] rebuilds. chokidar handles atomic-replace
+    // correctly because it watches paths by name and re-arms on
+    // rename. `awaitWriteFinish` further coalesces multi-event saves
+    // into a single emit.
+    //
+    // Watch siteRoot recursively + each declared source path. The
+    // top-level `ignored` patterns keep us out of the output dir
+    // (otherwise rebuilds would self-trigger), VCS metadata, OS
+    // junk, and editor swap files.
+    const watchPaths = collectWatchPaths(siteRoot, config);
+    const watcher = chokidar.watch(watchPaths, {
+        ignoreInitial: true,
+        ignored: [
+            /(^|[\\/])\.git([\\/]|$)/,
+            /(^|[\\/])node_modules([\\/]|$)/,
+            /(^|[\\/])astro([\\/]|$)/,
+            /(^|[\\/])dist([\\/]|$)/,
+            /(^|[\\/])\.dogsbay([\\/]|$)/,
+            /\.swp$/,
+            /\.swo$/,
+            /~$/,
+            /\.DS_Store$/,
+        ],
+        awaitWriteFinish: {
+            stabilityThreshold: 50,
+            pollInterval: 10,
+        },
+    });
+    // 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 (chokidar dedupes
+            // already-watched roots internally).
+            const newPaths = collectWatchPaths(siteRoot, config);
+            watcher.add(newPaths);
+            await siteBuild(siteRoot, {
+                includeDrafts: true,
+                primaryOnly: 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);
+        }
+    };
+    watcher.on("all", (_event, _path) => scheduleBuild());
+    // Diagnostic: show what's being watched on startup.
+    console.log(pc.gray(`[dogsbay] watching ${watchPaths.length} path${watchPaths.length === 1 ? "" : "s"} for content changes`));
+    return () => {
+        if (timer)
+            clearTimeout(timer);
+        void watcher.close();
+    };
+}
+/**
+ * Collect the absolute paths chokidar should watch: the site root
+ * (so `dogsbay.config.yml` edits trigger a reload) plus every
+ * declared `content.sources[].path`. Skips entries that don't exist
+ * on disk yet — chokidar would otherwise log a noisy ENOENT.
+ */
+function collectWatchPaths(siteRoot, config) {
+    const out = new Set();
+    if (existsSync(siteRoot))
+        out.add(siteRoot);
+    for (const source of config.content?.sources ?? []) {
+        if (typeof source.path === "string") {
+            const abs = resolve(siteRoot, source.path);
+            if (existsSync(abs))
+                out.add(abs);
+        }
+    }
+    return [...out];
+}
+function findOrFail(siteRoot, explicit) {
+    return resolveConfigPath(siteRoot, explicit);
 }
 function resolveConfigPath(startDir, explicit) {
     if (explicit) {