@maplab/hyperdoc 0.2.0

package/dist/index.js

@@ -0,0 +1,962 @@
+#!/usr/bin/env node
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// ../../packages/core/dist/errors.js
+var require_errors = __commonJS({
+  "../../packages/core/dist/errors.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.HyperdocError = void 0;
+    exports2.formatError = formatError2;
+    var HyperdocError = class extends Error {
+      constructor(message) {
+        super(message);
+        this.name = "HyperdocError";
+      }
+    };
+    exports2.HyperdocError = HyperdocError;
+    function formatError2(error, includeStack) {
+      if (error instanceof Error) {
+        if (includeStack && error.stack) {
+          return error.stack;
+        }
+        return error.message;
+      }
+      if (typeof error === "string") {
+        return error;
+      }
+      return "Unknown error";
+    }
+  }
+});
+
+// ../../packages/core/dist/utils/logger.js
+var require_logger = __commonJS({
+  "../../packages/core/dist/utils/logger.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.logger = exports2.LogLevel = void 0;
+    var LogLevel3;
+    (function(LogLevel4) {
+      LogLevel4[LogLevel4["DEBUG"] = 10] = "DEBUG";
+      LogLevel4[LogLevel4["INFO"] = 20] = "INFO";
+      LogLevel4[LogLevel4["WARN"] = 30] = "WARN";
+      LogLevel4[LogLevel4["ERROR"] = 40] = "ERROR";
+    })(LogLevel3 || (exports2.LogLevel = LogLevel3 = {}));
+    var Logger = class {
+      constructor() {
+        this.level = LogLevel3.INFO;
+      }
+      setLevel(level) {
+        this.level = level;
+      }
+      getLevel() {
+        return this.level;
+      }
+      logIf(level, fn, message) {
+        if (this.level <= level) {
+          fn(message);
+        }
+      }
+      debug(message) {
+        this.logIf(LogLevel3.DEBUG, console.log, message);
+      }
+      info(message) {
+        this.logIf(LogLevel3.INFO, console.log, message);
+      }
+      warn(message) {
+        this.logIf(LogLevel3.WARN, console.warn, message);
+      }
+      error(message) {
+        this.logIf(LogLevel3.ERROR, console.error, message);
+      }
+    };
+    exports2.logger = new Logger();
+  }
+});
+
+// ../../packages/core/dist/schemas/project.js
+var require_project = __commonJS({
+  "../../packages/core/dist/schemas/project.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.projectConfigSchema = void 0;
+    var zod_1 = require("zod");
+    exports2.projectConfigSchema = zod_1.z.object({
+      name: zod_1.z.string().trim().min(1).max(200).optional()
+    }).strict();
+  }
+});
+
+// ../../packages/core/dist/index.js
+var require_dist = __commonJS({
+  "../../packages/core/dist/index.js"(exports2) {
+    "use strict";
+    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = { enumerable: true, get: function() {
+          return m[k];
+        } };
+      }
+      Object.defineProperty(o, k2, desc);
+    }) : (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      o[k2] = m[k];
+    }));
+    var __exportStar = exports2 && exports2.__exportStar || function(m, exports3) {
+      for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports3, p)) __createBinding(exports3, m, p);
+    };
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    __exportStar(require_errors(), exports2);
+    __exportStar(require_logger(), exports2);
+    __exportStar(require_project(), exports2);
+  }
+});
+
+// ../../packages/adapter-markdown/dist/index.js
+var require_dist2 = __commonJS({
+  "../../packages/adapter-markdown/dist/index.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.extractMarkdownTitle = exports2.stripMarkdownMetadataHeader = exports2.getMarkdownMetadata = void 0;
+    var getMarkdownMetadata = (content) => {
+      const match = content.match(/^\uFEFF?\s*<!--\s*hyperdoc:([A-Za-z0-9+/=]+)\s*-->\s*(?:\r?\n|$)/i);
+      if (!match)
+        return null;
+      try {
+        const json = Buffer.from(match[1], "base64").toString("utf-8");
+        const parsed = JSON.parse(json);
+        if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+          return null;
+        }
+        const tagsRaw = parsed.tags;
+        const tags = Array.isArray(tagsRaw) ? tagsRaw.filter((tag) => typeof tag === "string") : [];
+        const pinned = parsed.pinned === true;
+        const title = typeof parsed.title === "string" ? parsed.title ?? null : null;
+        return { tags, pinned, title };
+      } catch {
+        return null;
+      }
+    };
+    exports2.getMarkdownMetadata = getMarkdownMetadata;
+    var metadataHeaderStrip = /^\uFEFF?\s*<!--\s*hyperdoc:[A-Za-z0-9+/=]+\s*-->\s*(?:\r?\n|$)/i;
+    var stripMetadataSpacer = (value) => {
+      if (!value)
+        return value;
+      const match = value.match(/^\s*(?:\r?\n)/);
+      if (match) {
+        return value.slice(match[0].length);
+      }
+      return value;
+    };
+    var stripMarkdownMetadataHeader = (content) => {
+      let output = content.replace(/^\uFEFF/, "");
+      let previous = "";
+      while (output !== previous) {
+        previous = output;
+        output = output.replace(metadataHeaderStrip, "");
+      }
+      return stripMetadataSpacer(output);
+    };
+    exports2.stripMarkdownMetadataHeader = stripMarkdownMetadataHeader;
+    var parseLegacyTitle = (content) => {
+      const match = content.match(/^\s*<!--\s*title:\s*(.+?)\s*-->\s*(?:\r?\n|$)/i);
+      return match ? match[1].trim() : null;
+    };
+    var extractMarkdownTitle = (content) => parseLegacyTitle(content);
+    exports2.extractMarkdownTitle = extractMarkdownTitle;
+  }
+});
+
+// ../../packages/server/dist/createApp.js
+var require_createApp = __commonJS({
+  "../../packages/server/dist/createApp.js"(exports2) {
+    "use strict";
+    var __importDefault = exports2 && exports2.__importDefault || function(mod) {
+      return mod && mod.__esModule ? mod : { "default": mod };
+    };
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.createApp = createApp2;
+    var express_1 = __importDefault(require("express"));
+    var chokidar_1 = __importDefault(require("chokidar"));
+    var fs_1 = __importDefault(require("fs"));
+    var path_1 = __importDefault(require("path"));
+    var adapter_markdown_1 = require_dist2();
+    var core_1 = require_dist();
+    function createApp2(options) {
+      const app = (0, express_1.default)();
+      const rootDir = path_1.default.resolve(options.rootDir);
+      const rootDirPrefix = rootDir.endsWith(path_1.default.sep) ? rootDir : `${rootDir}${path_1.default.sep}`;
+      const metadataFileName = "metadata.json";
+      const hyperdocDirName = ".hyperdoc";
+      const archiveDirName = "archive";
+      const trashDirName = "trash";
+      const projectFileName = "project.json";
+      const resolveDocPath = (name) => path_1.default.resolve(rootDir, name);
+      const isDocPathSafe = (filePath) => filePath.startsWith(rootDirPrefix);
+      const isMetadataName = (name) => name === metadataFileName;
+      const hyperdocDir = path_1.default.join(rootDir, hyperdocDirName);
+      const projectFilePath = path_1.default.join(hyperdocDir, projectFileName);
+      const ensureHyperdocDir = () => {
+        if (!fs_1.default.existsSync(hyperdocDir)) {
+          fs_1.default.mkdirSync(hyperdocDir, { recursive: true });
+        }
+      };
+      const readProjectConfig = () => {
+        if (!fs_1.default.existsSync(projectFilePath)) {
+          return { config: null, error: null };
+        }
+        try {
+          const raw = fs_1.default.readFileSync(projectFilePath, "utf-8");
+          const parsed = JSON.parse(raw);
+          const result = core_1.projectConfigSchema.safeParse(parsed);
+          if (!result.success) {
+            return { config: null, error: result.error };
+          }
+          return { config: result.data, error: null };
+        } catch (error) {
+          return { config: null, error };
+        }
+      };
+      const writeProjectConfig = (config) => {
+        ensureHyperdocDir();
+        const payload = JSON.stringify(config, null, 2);
+        fs_1.default.writeFileSync(projectFilePath, `${payload}
+`, "utf-8");
+      };
+      const decodeJsonMetadata = (content) => {
+        try {
+          const parsed = JSON.parse(content);
+          if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+            return null;
+          }
+          const metadataRaw = parsed.metadata;
+          if (!metadataRaw || typeof metadataRaw !== "object" || Array.isArray(metadataRaw)) {
+            return { tags: [] };
+          }
+          const metadata = metadataRaw;
+          const tags = Array.isArray(metadata.tags) ? metadata.tags.filter((tag) => typeof tag === "string") : [];
+          const pinned = metadata.pinned === true;
+          return { tags, pinned };
+        } catch {
+          return null;
+        }
+      };
+      const normalizeTags = (value) => {
+        if (!Array.isArray(value))
+          return [];
+        const cleaned = value.map((tag) => typeof tag === "string" ? tag.trim() : "").filter((tag) => tag.length > 0 && /^[a-z]+$/.test(tag));
+        return Array.from(new Set(cleaned)).sort();
+      };
+      const tagsFromContent = (name, content) => {
+        const ext = path_1.default.extname(name).toLowerCase();
+        if (ext === ".md") {
+          return (0, adapter_markdown_1.getMarkdownMetadata)(content)?.tags ?? [];
+        }
+        if (ext === ".json") {
+          return decodeJsonMetadata(content)?.tags ?? [];
+        }
+        return [];
+      };
+      const fileTags = /* @__PURE__ */ new Map();
+      const tagIndex = /* @__PURE__ */ new Set();
+      const indexFileTags = (name) => {
+        const filePath = resolveDocPath(name);
+        if (!fs_1.default.existsSync(filePath))
+          return;
+        try {
+          const content = fs_1.default.readFileSync(filePath, "utf-8");
+          const tags = normalizeTags(tagsFromContent(name, content));
+          fileTags.set(name, tags);
+        } catch {
+          fileTags.set(name, []);
+        }
+      };
+      const rebuildTagIndex = () => {
+        tagIndex.clear();
+        for (const tags of fileTags.values()) {
+          for (const tag of tags)
+            tagIndex.add(tag);
+        }
+      };
+      const refreshTagsFromDisk = () => {
+        fileTags.clear();
+        const entries = fs_1.default.readdirSync(rootDir, { withFileTypes: true }).filter((entry) => entry.isFile()).filter((entry) => entry.name.endsWith(".md") || entry.name.endsWith(".json")).filter((entry) => !isMetadataName(entry.name));
+        for (const entry of entries) {
+          indexFileTags(entry.name);
+        }
+        rebuildTagIndex();
+      };
+      refreshTagsFromDisk();
+      const validateDocName = (name) => {
+        if (!name)
+          return "Missing name";
+        if (name.includes("/") || name.includes("\\") || name.includes("..")) {
+          return "Invalid name";
+        }
+        return null;
+      };
+      const displayNameFromFileName = (name) => {
+        const base = name.replace(/\.(md|json)$/i, "");
+        const spaced = base.replace(/-+/g, " ").trim();
+        if (!spaced)
+          return base;
+        return `${spaced.charAt(0).toUpperCase()}${spaced.slice(1)}`;
+      };
+      app.use(express_1.default.text({ type: "*/*", limit: "5mb" }));
+      if (options.staticDir && fs_1.default.existsSync(options.staticDir)) {
+        app.use(express_1.default.static(options.staticDir));
+      }
+      app.get("/api/project", (req, res) => {
+        const { config, error } = readProjectConfig();
+        if (error) {
+          res.status(400).json({ error: "Invalid project config" });
+          return;
+        }
+        res.json({
+          name: config?.name ?? null,
+          exists: config !== null
+        });
+      });
+      app.put("/api/project", (req, res) => {
+        const raw = typeof req.body === "string" ? req.body : "";
+        if (!raw.trim()) {
+          res.status(400).send("Missing body");
+          return;
+        }
+        let parsed;
+        try {
+          parsed = JSON.parse(raw);
+        } catch {
+          res.status(400).send("Invalid JSON");
+          return;
+        }
+        const result = core_1.projectConfigSchema.safeParse(parsed);
+        if (!result.success) {
+          res.status(400).json({ error: "Invalid project config" });
+          return;
+        }
+        writeProjectConfig(result.data);
+        res.json({ name: result.data.name ?? null });
+      });
+      app.get("/api/docs", (req, res) => {
+        const entries = fs_1.default.readdirSync(rootDir, { withFileTypes: true }).filter((entry) => entry.isFile()).filter((entry) => entry.name.endsWith(".md") || entry.name.endsWith(".json")).filter((entry) => !isMetadataName(entry.name)).map((entry) => ({
+          name: entry.name,
+          type: entry.name.endsWith(".md") ? "markdown" : "json"
+        })).map((entry) => {
+          const filePath = resolveDocPath(entry.name);
+          if (entry.type === "markdown") {
+            let title = null;
+            let tags2 = [];
+            let pinned2 = false;
+            try {
+              const content = fs_1.default.readFileSync(filePath, "utf-8");
+              title = (0, adapter_markdown_1.extractMarkdownTitle)(content);
+              const metadata = (0, adapter_markdown_1.getMarkdownMetadata)(content);
+              tags2 = normalizeTags(metadata?.tags ?? []);
+              pinned2 = metadata?.pinned ?? false;
+            } catch {
+              title = null;
+              tags2 = [];
+              pinned2 = false;
+            }
+            return {
+              ...entry,
+              title,
+              tags: tags2,
+              pinned: pinned2,
+              displayName: title && title.length > 0 ? title : displayNameFromFileName(entry.name)
+            };
+          }
+          let tags = [];
+          let pinned = false;
+          try {
+            const content = fs_1.default.readFileSync(filePath, "utf-8");
+            const metadata = decodeJsonMetadata(content);
+            tags = normalizeTags(metadata?.tags ?? []);
+            pinned = metadata?.pinned ?? false;
+          } catch {
+            tags = [];
+            pinned = false;
+          }
+          return {
+            ...entry,
+            title: null,
+            tags,
+            pinned,
+            displayName: displayNameFromFileName(entry.name)
+          };
+        });
+        res.json(entries);
+      });
+      app.get("/api/docs/exists", (req, res) => {
+        const name = String(req.query.name ?? "");
+        if (!name) {
+          res.status(400).send("Missing name");
+          return;
+        }
+        if (name.includes("/") || name.includes("\\") || name.includes("..")) {
+          res.status(400).send("Invalid name");
+          return;
+        }
+        const filePath = resolveDocPath(name);
+        if (!isDocPathSafe(filePath)) {
+          res.status(400).send("Invalid path");
+          return;
+        }
+        res.json({ exists: fs_1.default.existsSync(filePath) });
+      });
+      app.post("/api/docs", (req, res) => {
+        let payload = null;
+        if (typeof req.body === "string") {
+          try {
+            payload = JSON.parse(req.body);
+          } catch {
+            payload = null;
+          }
+        } else if (req.body && typeof req.body === "object") {
+          payload = req.body;
+        }
+        const rawName = String(payload?.name ?? "").trim();
+        const rawType = payload?.type ?? null;
+        if (!rawType) {
+          res.status(400).send("Missing type");
+          return;
+        }
+        const name = rawName;
+        const nameError = validateDocName(name);
+        if (nameError) {
+          res.status(400).send(nameError);
+          return;
+        }
+        const hasMarkdownExt = name.endsWith(".md");
+        const hasJsonExt = name.endsWith(".json");
+        if (hasMarkdownExt && rawType !== "markdown") {
+          res.status(400).send("Name extension does not match type");
+          return;
+        }
+        if (hasJsonExt && rawType !== "json") {
+          res.status(400).send("Name extension does not match type");
+          return;
+        }
+        const fileName = hasMarkdownExt || hasJsonExt ? name : `${name}.${rawType === "json" ? "json" : "md"}`;
+        const filePath = resolveDocPath(fileName);
+        if (!isDocPathSafe(filePath)) {
+          res.status(400).send("Invalid path");
+          return;
+        }
+        if (fs_1.default.existsSync(filePath)) {
+          res.status(409).send("Name already exists");
+          return;
+        }
+        const content = payload?.content ?? (rawType === "json" ? JSON.stringify({ data: [] }, null, 2) : "");
+        fs_1.default.writeFileSync(filePath, content, "utf-8");
+        indexFileTags(fileName);
+        rebuildTagIndex();
+        const createdTags = normalizeTags(tagsFromContent(fileName, content));
+        const createdTitle = rawType === "markdown" ? (0, adapter_markdown_1.extractMarkdownTitle)(content) : null;
+        res.status(201).json({
+          name: fileName,
+          type: rawType,
+          title: createdTitle,
+          tags: createdTags,
+          displayName: createdTitle && createdTitle.length > 0 ? createdTitle : displayNameFromFileName(fileName)
+        });
+      });
+      app.post("/api/doc/rename", (req, res) => {
+        let payload = null;
+        if (typeof req.body === "string") {
+          try {
+            payload = JSON.parse(req.body);
+          } catch {
+            payload = null;
+          }
+        } else if (req.body && typeof req.body === "object") {
+          payload = req.body;
+        }
+        const from = String(payload?.from ?? "").trim();
+        const to = String(payload?.to ?? "").trim();
+        if (!from || !to) {
+          res.status(400).send("Missing rename target");
+          return;
+        }
+        const fromError = validateDocName(from);
+        if (fromError) {
+          res.status(400).send(fromError);
+          return;
+        }
+        const toError = validateDocName(to);
+        if (toError) {
+          res.status(400).send(toError);
+          return;
+        }
+        if (isMetadataName(from) || isMetadataName(to)) {
+          res.status(400).send("Reserved name");
+          return;
+        }
+        const fromPath = resolveDocPath(from);
+        const toPath = resolveDocPath(to);
+        if (!isDocPathSafe(fromPath) || !isDocPathSafe(toPath)) {
+          res.status(400).send("Invalid path");
+          return;
+        }
+        if (!fs_1.default.existsSync(fromPath)) {
+          res.status(404).send("Not found");
+          return;
+        }
+        if (fs_1.default.existsSync(toPath)) {
+          res.status(409).send("Name already exists");
+          return;
+        }
+        const fromExt = path_1.default.extname(from).toLowerCase();
+        const toExt = path_1.default.extname(to).toLowerCase();
+        if (fromExt !== toExt || fromExt !== ".md" && fromExt !== ".json") {
+          res.status(400).send("Name extension does not match type");
+          return;
+        }
+        fs_1.default.renameSync(fromPath, toPath);
+        if (fromExt === ".md" || fromExt === ".json") {
+          fileTags.delete(from);
+          indexFileTags(to);
+          rebuildTagIndex();
+        }
+        res.json({
+          name: to,
+          type: fromExt === ".json" ? "json" : "markdown",
+          title: null,
+          displayName: displayNameFromFileName(to)
+        });
+      });
+      app.post("/api/doc/:name/archive", (req, res) => {
+        const name = String(req.params.name);
+        if (isMetadataName(name)) {
+          res.status(400).send("Reserved name");
+          return;
+        }
+        if (name.includes("/") || name.includes("\\") || name.includes("..")) {
+          res.status(400).send("Invalid name");
+          return;
+        }
+        const filePath = resolveDocPath(name);
+        if (!isDocPathSafe(filePath)) {
+          res.status(400).send("Invalid path");
+          return;
+        }
+        if (!fs_1.default.existsSync(filePath)) {
+          res.status(404).send("Not found");
+          return;
+        }
+        const archiveDir = path_1.default.join(hyperdocDir, archiveDirName);
+        ensureHyperdocDir();
+        if (!fs_1.default.existsSync(archiveDir)) {
+          fs_1.default.mkdirSync(archiveDir, { recursive: true });
+        }
+        const archivePath = path_1.default.join(archiveDir, name);
+        if (fs_1.default.existsSync(archivePath)) {
+          res.status(409).send("Archived file already exists with that name");
+          return;
+        }
+        fs_1.default.renameSync(filePath, archivePath);
+        fileTags.delete(name);
+        rebuildTagIndex();
+        res.json({ archived: true, name });
+      });
+      app.get("/api/doc/:name", (req, res) => {
+        const name = String(req.params.name);
+        if (isMetadataName(name)) {
+          res.status(400).send("Reserved name");
+          return;
+        }
+        const filePath = resolveDocPath(name);
+        if (!isDocPathSafe(filePath)) {
+          res.status(400).send("Invalid path");
+          return;
+        }
+        if (!fs_1.default.existsSync(filePath)) {
+          res.status(404).send("Not found");
+          return;
+        }
+        const content = fs_1.default.readFileSync(filePath, "utf-8");
+        const stat = fs_1.default.statSync(filePath);
+        const ext = path_1.default.extname(name).toLowerCase();
+        if (ext === ".md") {
+          const metadata = (0, adapter_markdown_1.getMarkdownMetadata)(content);
+          res.json({
+            content: (0, adapter_markdown_1.stripMarkdownMetadataHeader)(content),
+            mtimeMs: stat.mtimeMs,
+            metadata
+          });
+          return;
+        }
+        res.json({ content, mtimeMs: stat.mtimeMs });
+      });
+      app.put("/api/doc/:name", (req, res) => {
+        const name = String(req.params.name);
+        if (isMetadataName(name)) {
+          res.status(400).send("Reserved name");
+          return;
+        }
+        const filePath = resolveDocPath(name);
+        if (!isDocPathSafe(filePath)) {
+          res.status(400).send("Invalid path");
+          return;
+        }
+        if (!fs_1.default.existsSync(filePath)) {
+          res.status(404).send("Not found");
+          return;
+        }
+        const baseHeader = req.header("x-hyperdoc-base-version");
+        if (baseHeader !== void 0) {
+          const baseVersion = Number(baseHeader);
+          if (!Number.isFinite(baseVersion)) {
+            res.status(400).send("Invalid base version");
+            return;
+          }
+          const currentStat = fs_1.default.statSync(filePath);
+          if (currentStat.mtimeMs !== baseVersion) {
+            res.status(409).json({ mtimeMs: currentStat.mtimeMs });
+            return;
+          }
+        }
+        fs_1.default.writeFileSync(filePath, req.body ?? "", "utf-8");
+        const stat = fs_1.default.statSync(filePath);
+        const clientId = req.header("x-hyperdoc-client-id");
+        if (clientId) {
+          recentWrites.set(name, {
+            clientId,
+            ts: Date.now(),
+            mtimeMs: stat.mtimeMs
+          });
+        }
+        res.json({ mtimeMs: stat.mtimeMs });
+      });
+      app.delete("/api/doc/:name", (req, res) => {
+        const name = String(req.params.name);
+        if (isMetadataName(name)) {
+          res.status(400).send("Reserved name");
+          return;
+        }
+        if (name.includes("/") || name.includes("\\") || name.includes("..")) {
+          res.status(400).send("Invalid name");
+          return;
+        }
+        const filePath = resolveDocPath(name);
+        if (!isDocPathSafe(filePath)) {
+          res.status(400).send("Invalid path");
+          return;
+        }
+        if (!fs_1.default.existsSync(filePath)) {
+          res.status(404).send("Not found");
+          return;
+        }
+        const trashDir = path_1.default.join(hyperdocDir, trashDirName);
+        ensureHyperdocDir();
+        if (!fs_1.default.existsSync(trashDir)) {
+          fs_1.default.mkdirSync(trashDir, { recursive: true });
+          fs_1.default.writeFileSync(path_1.default.join(trashDir, ".gitignore"), "*\n!.gitignore\n");
+        }
+        const trashPath = path_1.default.join(trashDir, name);
+        if (fs_1.default.existsSync(trashPath)) {
+          const ext = path_1.default.extname(name);
+          const base = name.slice(0, -ext.length);
+          const timestamp = Date.now();
+          const uniqueName = `${base}-${timestamp}${ext}`;
+          fs_1.default.renameSync(filePath, path_1.default.join(trashDir, uniqueName));
+        } else {
+          fs_1.default.renameSync(filePath, trashPath);
+        }
+        fileTags.delete(name);
+        rebuildTagIndex();
+        res.json({ deleted: true });
+      });
+      app.get("/api/tags", (req, res) => {
+        res.json({ tags: Array.from(tagIndex).sort() });
+      });
+      const clients = /* @__PURE__ */ new Set();
+      const recentWrites = /* @__PURE__ */ new Map();
+      const watcher = chokidar_1.default.watch(rootDir, {
+        ignoreInitial: true,
+        ignored: (target) => {
+          const rel = path_1.default.relative(rootDir, target);
+          if (!rel)
+            return false;
+          if (rel.startsWith(".git"))
+            return true;
+          if (rel.startsWith(hyperdocDirName))
+            return true;
+          if (rel.startsWith(".trash"))
+            return true;
+          if (rel.startsWith(".archive"))
+            return true;
+          if (rel.startsWith("node_modules"))
+            return true;
+          if (rel.startsWith("dist"))
+            return true;
+          return false;
+        }
+      });
+      watcher.on("all", (event, filePath) => {
+        if (!filePath.endsWith(".md") && !filePath.endsWith(".json"))
+          return;
+        if (path_1.default.basename(filePath) === metadataFileName)
+          return;
+        const name = path_1.default.basename(filePath);
+        if (name.endsWith(".md") || name.endsWith(".json")) {
+          if (event === "unlink") {
+            fileTags.delete(name);
+            recentWrites.delete(name);
+          } else {
+            indexFileTags(name);
+          }
+          rebuildTagIndex();
+        }
+        let mtimeMs;
+        if (event !== "unlink") {
+          try {
+            const stat = fs_1.default.statSync(filePath);
+            mtimeMs = stat.mtimeMs;
+          } catch {
+            mtimeMs = void 0;
+          }
+        }
+        const recent = recentWrites.get(name);
+        const sourceId = recent && Date.now() - recent.ts < 2e3 ? recent.clientId : void 0;
+        const payload = JSON.stringify({ type: event, name, mtimeMs, sourceId });
+        for (const client of clients) {
+          client.write(`data: ${payload}
+
+`);
+        }
+      });
+      app.get("/api/events", (req, res) => {
+        res.setHeader("Content-Type", "text/event-stream");
+        res.setHeader("Cache-Control", "no-cache");
+        res.setHeader("Connection", "keep-alive");
+        res.flushHeaders();
+        clients.add(res);
+        req.on("close", () => {
+          clients.delete(res);
+        });
+      });
+      return app;
+    }
+  }
+});
+
+// ../../packages/server/dist/index.js
+var require_dist3 = __commonJS({
+  "../../packages/server/dist/index.js"(exports2) {
+    "use strict";
+    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = { enumerable: true, get: function() {
+          return m[k];
+        } };
+      }
+      Object.defineProperty(o, k2, desc);
+    }) : (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      o[k2] = m[k];
+    }));
+    var __exportStar = exports2 && exports2.__exportStar || function(m, exports3) {
+      for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports3, p)) __createBinding(exports3, m, p);
+    };
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    __exportStar(require_createApp(), exports2);
+  }
+});
+
+// src/cli/CommanderCli.ts
+var import_commander = require("commander");
+
+// src/commands/PromptCommand.ts
+var import_fs = __toESM(require("fs"));
+var import_path = __toESM(require("path"));
+var PromptCommand = class {
+  async execute(context) {
+    void context;
+    const promptPath = import_path.default.join(__dirname, "..", "prompts", "agent.txt");
+    const prompt = import_fs.default.readFileSync(promptPath, "utf-8");
+    process.stdout.write(prompt);
+    if (!prompt.endsWith("\n")) {
+      process.stdout.write("\n");
+    }
+  }
+};
+
+// src/commands/ServerCommand.ts
+var import_fs2 = __toESM(require("fs"));
+var import_path2 = __toESM(require("path"));
+var import_open = __toESM(require("open"));
+var import_core = __toESM(require_dist());
+var import_server = __toESM(require_dist3());
+var DEFAULT_PORT = 4321;
+var ServerCommand = class {
+  async execute(context) {
+    const rootDir = import_path2.default.resolve(context.options.root ?? process.cwd());
+    const port = Number(
+      context.options.port ?? process.env.HYPERDOC_PORT ?? DEFAULT_PORT
+    );
+    const webDir = import_path2.default.join(__dirname, "..", "web");
+    if (!import_fs2.default.existsSync(webDir)) {
+      import_core.logger.warn(
+        `Web bundle not found at ${webDir}. Run pnpm --filter hyperdoc-web build.`
+      );
+    }
+    const app = (0, import_server.createApp)({ rootDir, staticDir: webDir });
+    app.get("*", (req, res) => {
+      const indexPath = import_path2.default.join(webDir, "index.html");
+      if (import_fs2.default.existsSync(indexPath)) {
+        res.sendFile(indexPath);
+      } else {
+        res.status(500).send("Web bundle missing. Run pnpm build:web.");
+      }
+    });
+    app.listen(port, () => {
+      const url = `http://localhost:${port}`;
+      import_core.logger.info(`Hyperdoc server running at ${url}`);
+      if (context.options.open) {
+        (0, import_open.default)(url).catch(() => void 0);
+      }
+    });
+  }
+};
+
+// src/cli/CommanderCli.ts
+var import_core2 = __toESM(require_dist());
+
+// package.json
+var package_default = {
+  name: "@maplab/hyperdoc",
+  version: "0.2.0",
+  description: "Hyperdoc CLI and local server",
+  type: "commonjs",
+  main: "dist/index.js",
+  types: "dist/index.d.ts",
+  bin: {
+    hyper: "dist/index.js"
+  },
+  files: [
+    "dist"
+  ],
+  publishConfig: {
+    access: "public"
+  },
+  scripts: {
+    build: "tsup && node scripts/copy-prompts.js && node scripts/copy-web.js",
+    dev: "tsx src/index.ts",
+    start: "node dist/index.js",
+    typecheck: "tsc -p tsconfig.json --noEmit"
+  },
+  dependencies: {
+    chokidar: "^5.0.0",
+    commander: "^14.0.0",
+    "markdown-it": "^14.1.0",
+    open: "^9.1.0",
+    express: "^4.19.2",
+    zod: "^4.1.5"
+  },
+  devDependencies: {
+    "@hyperdoc/core": "workspace:*",
+    "@hyperdoc/server": "workspace:*",
+    tsup: "^8.5.0"
+  }
+};
+
+// src/cli/CommanderCli.ts
+var CommanderCli = class {
+  constructor() {
+    this.commandHandlers = /* @__PURE__ */ new Map();
+    this.program = new import_commander.Command();
+    this.setupCommandHandlers();
+    this.setupProgram();
+  }
+  setupCommandHandlers() {
+    this.commandHandlers.set("prompt", new PromptCommand());
+    this.commandHandlers.set("server", new ServerCommand());
+  }
+  setupProgram() {
+    this.program.name("hyper").description("Local Hyperdoc server and tooling").version(package_default.version);
+    this.program.option("--root <dir>", "Project root (defaults to cwd)").option("-v, --verbose", "Increase logging verbosity").option("-q, --quiet", "Reduce logging output").option("-d, --debug", "Enable debug logging");
+    this.program.command("prompt").description("Print the agent prompt/spec to stdout").action(async (options, command) => {
+      await this.executeCommand("prompt", command);
+    });
+    this.program.command("server").description("Start the local Hyperdoc server").option(
+      "--port <number>",
+      "Port to run the server on",
+      (value) => Number(value)
+    ).option("-o, --open", "Open the UI in the browser").action(async (options, command) => {
+      await this.executeCommand("server", command);
+    });
+  }
+  async executeCommand(command, commandInstance) {
+    const parent = commandInstance.parent;
+    const globalOpts = parent.opts();
+    const commandOpts = commandInstance.opts();
+    const allOptions = { ...globalOpts, ...commandOpts };
+    if (allOptions.debug) {
+      import_core2.logger.setLevel(import_core2.LogLevel.DEBUG);
+    } else if (allOptions.verbose) {
+      import_core2.logger.setLevel(import_core2.LogLevel.INFO);
+    } else if (allOptions.quiet) {
+      import_core2.logger.setLevel(import_core2.LogLevel.WARN);
+    }
+    const handler = this.commandHandlers.get(command);
+    if (!handler) {
+      throw new Error(`No handler found for command: ${command}`);
+    }
+    await handler.execute({ options: allOptions });
+  }
+  async parse(args) {
+    await this.program.parseAsync(args);
+  }
+  getHelp() {
+    return this.program.helpInformation();
+  }
+};
+
+// src/index.ts
+var import_core3 = __toESM(require_dist());
+var cli = new CommanderCli();
+async function main() {
+  try {
+    await cli.parse(process.argv);
+  } catch (error) {
+    const showStackTrace = import_core3.logger.getLevel() === import_core3.LogLevel.DEBUG;
+    const formattedError = (0, import_core3.formatError)(error, showStackTrace);
+    console.error(formattedError);
+    process.exit(1);
+  }
+}
+main();
+//# sourceMappingURL=index.js.map