dogsbay 0.2.0-beta.6 → 0.2.0-beta.8

package/dist/commands/agent.js

@@ -17,7 +17,7 @@
  * See plans/dogsbay-agent-skills.md for the four-tier ownership
  * model and how this fits.
  */
-import { existsSync, mkdirSync, symlinkSync, unlinkSync, writeFileSync, readlinkSync } from "node:fs";
+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";
@@ -25,15 +25,22 @@ const SUPPORTED_AGENTS = ["claude", "cursor"];
 const AGENT_TARGETS = {
     claude: {
         name: "claude",
-        path: ".claude/skills/dogsbay",
-        label: "Claude Code (.claude/skills/dogsbay/)",
+        skillsDir: ".claude/skills",
+        label: "Claude Code",
     },
     cursor: {
         name: "cursor",
-        path: ".cursor/rules/dogsbay",
-        label: "Cursor (.cursor/rules/dogsbay/)",
+        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
@@ -99,13 +106,58 @@ The agent loader checks overrides first.
     if (!existsSync(pluginsDir)) {
         mkdirSync(pluginsDir, { recursive: true });
     }
-    // 2. Per-agent discovery symlinks.
+    // 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 agentLink = join(projectRoot, target.path);
-        mkdirSync(dirname(agentLink), { recursive: true });
-        refreshSymlink(agentLink, skillsDir);
-        console.log(pc.green(`  ✓ ${target.label} → .dogsbay/skills/`));
+        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:"));
@@ -180,6 +232,34 @@ function printDetected(projectRoot) {
     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
@@ -205,12 +285,21 @@ function refreshSymlink(linkPath, target) {
     }
     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 {
-        readlinkSync(p);
-        return true; // it's a symlink, regardless of target validity
+        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-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.6",
+  "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-astro": "0.2.0-beta.6",
-    "@dogsbay/format-obsidian": "0.2.0-beta.6",
-    "@dogsbay/format-mkdocs": "0.2.0-beta.6",
-    "@dogsbay/format-mdx": "0.2.0-beta.6",
-    "@dogsbay/format-starlight": "0.2.0-beta.6",
-    "@dogsbay/format-dogsbay-md": "0.2.0-beta.6",
-    "@dogsbay/format-openapi": "0.2.0-beta.6",
-    "@dogsbay/types": "0.2.0-beta.6"
+    "@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",