md-task-viewer 0.1.0

package/dist/client/assets/index-D8W_VwBM.css

@@ -0,0 +1 @@
+:root{color-scheme:dark;--bg: #0a0e14;--bg-strong: #0d1117;--panel: #131920;--panel-border: #21262d;--text: #e6edf3;--muted: #7d8590;--accent: #3fb950;--accent-strong: #2ea043;--danger: #f85149;--shadow: 0 2px 8px rgba(0, 0, 0, .4);font-family:JetBrains Mono,IBM Plex Mono,Fira Code,SF Mono,Cascadia Code,monospace;line-height:1.6;color:var(--text);background:var(--bg)}*{box-sizing:border-box}body{margin:0;height:100vh;overflow:hidden}#root{height:100vh;overflow:hidden}button,input,select,textarea{font:inherit}button{cursor:pointer}.app-shell{display:flex;flex-direction:column;height:100vh;padding:12px 16px 16px;gap:12px;overflow:hidden}.app-header{display:flex;justify-content:space-between;align-items:center;gap:16px;flex-shrink:0;padding-bottom:12px;border-bottom:1px solid var(--panel-border)}.app-header-left{display:flex;align-items:baseline;gap:12px;min-width:0}.app-header h1{margin:0;font-family:inherit;font-size:1.1rem;font-weight:700;line-height:1.2;letter-spacing:-.02em;white-space:nowrap;color:var(--accent)}.app-header h1:before{content:"> ";color:var(--muted)}.eyebrow{margin:0;color:var(--muted);text-transform:uppercase;letter-spacing:.12em;font-size:.65rem;font-weight:600;white-space:nowrap}.layout-grid{display:grid;grid-template-columns:minmax(260px,320px) minmax(0,1fr);gap:1px;flex:1;min-height:0;background:var(--panel-border)}.panel{display:flex;flex-direction:column;background:var(--panel);border:none;border-radius:0;padding:14px 16px;min-height:0;overflow:hidden}.panel-header{display:flex;justify-content:space-between;align-items:center;gap:12px;margin-bottom:12px;padding-bottom:8px;border-bottom:1px solid var(--panel-border);flex-shrink:0}.panel-header h2{margin:0;font-family:inherit;font-size:.85rem;font-weight:700;letter-spacing:.04em;text-transform:uppercase;color:var(--muted)}.panel-header span{font-size:.75rem;color:var(--muted)}.panel-header-right{display:flex;align-items:center;gap:12px}.filter-toggle{display:flex;align-items:center;gap:4px;cursor:pointer;-webkit-user-select:none;user-select:none}.filter-toggle input[type=checkbox]{accent-color:var(--accent);cursor:pointer}.sidebar-scroll{flex:1;overflow-y:auto;min-height:0;margin:0 -4px;padding:0 4px}.sidebar-scroll::-webkit-scrollbar{width:4px}.sidebar-scroll::-webkit-scrollbar-track{background:transparent}.sidebar-scroll::-webkit-scrollbar-thumb{background:var(--panel-border);border-radius:0}.task-list{display:grid;gap:2px}.empty-list{margin:0;padding:14px;border-radius:0;background:#ffffff08;border:1px dashed var(--panel-border);color:var(--muted);font-size:.82rem}.task-row{display:grid;gap:3px;width:100%;text-align:left;padding:8px 10px;border-radius:0;border:1px solid transparent;border-left:2px solid transparent;background:#ffffff05;transition:background .1s ease,border-color .1s ease}.task-row:hover{background:#ffffff0d;border-left-color:var(--muted)}.task-row-selected{background:#3fb9500f;border-color:#3fb95026;border-left-color:var(--accent)}.task-row-badges{display:flex;gap:6px;align-items:center}.task-row strong{font-size:.82rem;font-weight:600;line-height:1.3}.task-row small{color:var(--muted);font-size:.72rem}.badge{display:inline-flex;justify-content:center;width:fit-content;padding:1px 6px;border-radius:0;font-size:.6rem;font-weight:700;letter-spacing:.06em;text-transform:uppercase;border:1px solid}.badge-must{background:#f851491a;color:#f85149;border-color:#f851494d}.badge-want{background:#3fb9501a;color:#3fb950;border-color:#3fb9504d}.badge-todo{background:#58a6ff1a;color:#58a6ff;border-color:#58a6ff4d}.badge-wip{background:#d299221a;color:#d29922;border-color:#d299224d}.badge-done{background:#3fb95014;color:#2ea043;border-color:#2ea0434d}.editor-panel{overflow:hidden}.editor-scroll{flex:1;overflow-y:auto;min-height:0;margin:0 -4px;padding:0 4px}.editor-scroll::-webkit-scrollbar{width:4px}.editor-scroll::-webkit-scrollbar-track{background:transparent}.editor-scroll::-webkit-scrollbar-thumb{background:var(--panel-border);border-radius:0}.task-form{display:flex;flex-direction:column;gap:12px;height:100%}.task-form label{display:grid;gap:4px}.task-form span{font-size:.72rem;font-weight:600;color:var(--muted);text-transform:uppercase;letter-spacing:.08em}.task-form input,.task-form select,.task-form textarea{width:100%;padding:7px 10px;border:1px solid var(--panel-border);border-radius:0;background:var(--bg);color:var(--text);font-size:.88rem;transition:border-color .1s ease}.task-form input:focus,.task-form select:focus,.task-form textarea:focus{outline:none;border-color:var(--accent)}.task-form textarea{resize:none;flex:1;min-height:120px}.editor-label{flex:1;display:flex!important;flex-direction:column;min-height:0}.field-row{display:grid;grid-template-columns:repeat(2,minmax(0,1fr));gap:12px}.field-row-top{padding-bottom:12px;border-bottom:1px solid var(--panel-border)}.meta-strip{display:flex;gap:16px;color:var(--muted);font-size:.72rem}.form-actions{display:flex;gap:8px;flex-shrink:0;padding-top:4px}.primary-button,.danger-button,.ghost-button{border:1px solid;border-radius:0;padding:6px 14px;font-size:.8rem;font-weight:700;letter-spacing:.03em;text-transform:uppercase;transition:background .1s ease,color .1s ease}.primary-button{color:var(--bg);background:var(--accent);border-color:var(--accent)}.primary-button:hover{background:var(--accent-strong);border-color:var(--accent-strong)}.danger-button{color:var(--danger);background:#f851491a;border-color:#f8514966}.danger-button:hover{background:#f8514933}.ghost-button{color:var(--muted);background:transparent;border-color:var(--panel-border)}.ghost-button:hover{color:var(--text);background:#ffffff0d;border-color:var(--muted)}.primary-button:active,.danger-button:active,.ghost-button:active{transform:scale(.98)}.primary-button:disabled,.danger-button:disabled{opacity:.4;cursor:not-allowed}.dirty-state{color:var(--accent);font-weight:700;font-size:.72rem;white-space:nowrap}.notice{margin:0;padding-top:6px;color:var(--accent);font-size:.8rem;flex-shrink:0}.empty-editor{display:grid;place-items:center;flex:1;color:var(--muted);font-size:.85rem}.empty-editor p{margin:0}.error-panel{margin-top:12px;padding:10px 12px;border-radius:0;background:#f8514914;border:1px solid rgba(248,81,73,.2);flex-shrink:0}.error-panel h3{margin:0;font-family:inherit;font-size:.82rem;color:var(--danger)}.error-panel p{margin:8px 0 0;display:grid;font-size:.78rem}.app-header-actions{display:flex;gap:8px;align-items:center}.settings-button{display:inline-flex;align-items:center;justify-content:center;padding:6px;color:var(--muted);border:1px solid transparent;background:transparent;transition:color .1s ease,border-color .1s ease}.settings-button:hover{color:var(--text);border-color:var(--panel-border)}.settings-overlay{position:fixed;top:0;right:0;bottom:0;left:0;z-index:100;display:grid;place-items:center;background:#0009}.settings-modal{background:var(--panel);border:1px solid var(--panel-border);border-radius:0;box-shadow:var(--shadow);padding:20px;width:90%;max-width:480px;display:flex;flex-direction:column;gap:16px}.settings-body{display:flex;flex-direction:column;gap:10px}.settings-label{font-size:.75rem;font-weight:600;color:var(--muted);text-transform:uppercase;letter-spacing:.08em}.settings-hint{display:block;font-size:.72rem;color:var(--muted);margin-top:2px}.settings-dir-list{display:flex;flex-direction:column;gap:6px}.settings-dir-row{display:flex;gap:6px;align-items:center}.settings-dir-row input{flex:1;padding:7px 10px;border:1px solid var(--panel-border);border-radius:0;background:var(--bg);color:var(--text);font-size:.88rem;transition:border-color .1s ease}.settings-dir-row input:focus{outline:none;border-color:var(--accent)}.settings-remove-button{padding:6px!important;color:var(--muted);flex-shrink:0}.settings-remove-button:disabled{opacity:.3;cursor:not-allowed}@media(max-width:900px){.app-shell{padding:10px;height:auto;min-height:100vh;overflow:auto}body,#root{height:auto;overflow:auto}.layout-grid{grid-template-columns:1fr;flex:none}.panel{min-height:auto;max-height:none;overflow:visible}.sidebar-scroll,.editor-scroll{overflow:visible;max-height:none}.app-header{flex-direction:column;align-items:stretch;gap:10px}.app-header-left{flex-direction:column;gap:4px}.field-row{grid-template-columns:1fr}.task-form textarea{min-height:200px;flex:none}}

package/dist/client/index.html

@@ -0,0 +1,13 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>Markdown Task Viewer</title>
+    <script type="module" crossorigin src="/assets/index-CJzl_cjb.js"></script>
+    <link rel="stylesheet" crossorigin href="/assets/index-D8W_VwBM.css">
+  </head>
+  <body>
+    <div id="root"></div>
+  </body>
+</html>

package/dist/server.js

@@ -0,0 +1,579 @@
+// src/server.ts
+import Fastify from "fastify";
+import fastifyStatic from "@fastify/static";
+import chokidar from "chokidar";
+import path2 from "path";
+import { fileURLToPath } from "url";
+
+// src/taskStore.ts
+import matter from "gray-matter";
+import picomatch from "picomatch";
+import path from "path";
+import { promises as fs } from "fs";
+
+// src/types.ts
+var CONFIG_FILE_NAME = ".md-task-viewer.json";
+
+// src/taskStore.ts
+var MARKDOWN_EXTENSIONS = /* @__PURE__ */ new Set([".md", ".markdown"]);
+var REQUIRED_PRIORITY = ["MUST", "WANT"];
+var REQUIRED_STATUS = ["TODO", "WIP", "DONE"];
+var ConflictError = class extends Error {
+};
+var ValidationError = class extends Error {
+};
+function toPosixPath(filePath) {
+  return filePath.split(path.sep).join("/");
+}
+function normalizeRelativePath(candidate) {
+  const normalized = toPosixPath(path.posix.normalize(candidate.trim()));
+  if (!normalized || normalized === "." || normalized.startsWith("../") || normalized.includes("/../")) {
+    throw new ValidationError("Path must stay within the workspace root.");
+  }
+  return normalized.replace(/^\.\/+/, "");
+}
+function ensureMarkdownExtension(filePath) {
+  return path.posix.extname(filePath) ? filePath : `${filePath}.md`;
+}
+function asUtcISOString(date) {
+  return date.toISOString();
+}
+function slugify(value) {
+  const slug = value.toLowerCase().normalize("NFKD").replace(/[\u0300-\u036f]/g, "").replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+  return slug || "untitled-task";
+}
+function buildDefaults(filePath, stats) {
+  const basename = path.basename(filePath, path.extname(filePath));
+  const title = basename.replace(/[-_]+/g, " ").replace(/\b\w/g, (char) => char.toUpperCase());
+  return {
+    title,
+    priority: "WANT",
+    status: "TODO",
+    createdAt: asUtcISOString(stats.birthtime),
+    updatedAt: asUtcISOString(stats.mtime)
+  };
+}
+function splitFrontmatter(data, statsDefaults) {
+  const extraFrontmatter = {};
+  for (const [key, value] of Object.entries(data)) {
+    if (!["title", "priority", "status", "createdAt", "updatedAt"].includes(key)) {
+      extraFrontmatter[key] = value;
+    }
+  }
+  const title = typeof data.title === "string" && data.title.trim() ? data.title : statsDefaults.title;
+  const priority = REQUIRED_PRIORITY.includes(data.priority) ? data.priority : statsDefaults.priority;
+  const status = REQUIRED_STATUS.includes(data.status) ? data.status : statsDefaults.status;
+  const createdAt = typeof data.createdAt === "string" && !Number.isNaN(Date.parse(data.createdAt)) ? new Date(data.createdAt).toISOString() : statsDefaults.createdAt;
+  const updatedAt = typeof data.updatedAt === "string" && !Number.isNaN(Date.parse(data.updatedAt)) ? new Date(data.updatedAt).toISOString() : statsDefaults.updatedAt;
+  const normalized = title !== data.title || priority !== data.priority || status !== data.status || createdAt !== data.createdAt || updatedAt !== data.updatedAt;
+  return {
+    frontmatter: { title, priority, status, createdAt, updatedAt },
+    extraFrontmatter,
+    normalized
+  };
+}
+function serializeTask(record) {
+  const data = {
+    ...record.extraFrontmatter,
+    title: record.frontmatter.title,
+    priority: record.frontmatter.priority,
+    status: record.frontmatter.status,
+    createdAt: record.frontmatter.createdAt,
+    updatedAt: record.frontmatter.updatedAt
+  };
+  return matter.stringify(record.content, data);
+}
+async function readDirectoryRecursive(rootDir, currentDir, results) {
+  const entries = await fs.readdir(currentDir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (entry.name === ".git" || entry.name === "node_modules") {
+      continue;
+    }
+    const absolutePath = path.join(currentDir, entry.name);
+    if (entry.isDirectory()) {
+      await readDirectoryRecursive(rootDir, absolutePath, results);
+      continue;
+    }
+    if (entry.name === CONFIG_FILE_NAME) {
+      continue;
+    }
+    if (!MARKDOWN_EXTENSIONS.has(path.extname(entry.name).toLowerCase())) {
+      continue;
+    }
+    results.push(toPosixPath(path.relative(rootDir, absolutePath)));
+  }
+}
+async function listMarkdownFiles(rootDir, taskDirs, ignorePaths) {
+  const results = [];
+  const seen = /* @__PURE__ */ new Set();
+  const isIgnored = ignorePaths.length > 0 ? picomatch(ignorePaths) : null;
+  for (const taskDir of taskDirs) {
+    const scanDir = path.resolve(rootDir, taskDir);
+    try {
+      await fs.access(scanDir);
+    } catch {
+      continue;
+    }
+    const dirResults = [];
+    await readDirectoryRecursive(rootDir, scanDir, dirResults);
+    for (const filePath of dirResults) {
+      if (!seen.has(filePath)) {
+        seen.add(filePath);
+        if (isIgnored && isIgnored(filePath)) {
+          continue;
+        }
+        results.push(filePath);
+      }
+    }
+  }
+  return results.sort();
+}
+async function parseTask(rootDir, relativePath) {
+  const absolutePath = path.join(rootDir, relativePath);
+  const raw = await fs.readFile(absolutePath, "utf8");
+  const stats = await fs.stat(absolutePath);
+  const parsed = matter(raw);
+  const defaults = buildDefaults(relativePath, stats);
+  const { frontmatter, extraFrontmatter, normalized } = splitFrontmatter(parsed.data, defaults);
+  return {
+    path: toPosixPath(relativePath),
+    content: parsed.content,
+    frontmatter,
+    extraFrontmatter,
+    raw,
+    normalized
+  };
+}
+async function readConfig(rootDir) {
+  const configFilePath = path.join(rootDir, CONFIG_FILE_NAME);
+  try {
+    const raw = await fs.readFile(configFilePath, "utf8");
+    const parsed = JSON.parse(raw);
+    const taskDirs = Array.isArray(parsed.taskDirs) ? parsed.taskDirs.filter((item) => typeof item === "string") : ["."];
+    const ignorePaths = Array.isArray(parsed.ignorePaths) ? parsed.ignorePaths.filter((item) => typeof item === "string") : [];
+    const order = Array.isArray(parsed.order) ? parsed.order.filter((item) => typeof item === "string") : [];
+    return { version: parsed.version ?? 1, taskDirs, ignorePaths, order };
+  } catch (error) {
+    const maybeError = error;
+    if (maybeError.code !== "ENOENT") {
+      throw error;
+    }
+    return { version: 1, taskDirs: ["."], ignorePaths: [], order: [] };
+  }
+}
+async function reconcileOrder(rootDir, taskPaths) {
+  const config = await readConfig(rootDir);
+  const order = config.order;
+  const known = new Set(taskPaths);
+  const nextOrder = order.filter((item) => known.has(item));
+  for (const taskPath of taskPaths) {
+    if (!nextOrder.includes(taskPath)) {
+      nextOrder.push(taskPath);
+    }
+  }
+  const changed = nextOrder.length !== order.length || nextOrder.some((item, index) => item !== order[index]);
+  return { order: nextOrder, changed };
+}
+async function saveOrder(rootDir, order) {
+  const normalized = Array.from(
+    new Set(
+      order.map((item) => ensureMarkdownExtension(normalizeRelativePath(item)))
+    )
+  );
+  const existing = await readConfig(rootDir);
+  const payload = { version: 1, taskDirs: existing.taskDirs, ignorePaths: existing.ignorePaths, order: normalized };
+  await fs.writeFile(path.join(rootDir, CONFIG_FILE_NAME), `${JSON.stringify(payload, null, 2)}
+`, "utf8");
+}
+async function saveConfig(rootDir, taskDirs, ignorePaths) {
+  const validated = taskDirs.map((dir) => {
+    const normalized = dir.trim().replace(/\\/g, "/").replace(/\/+$/, "") || ".";
+    if (normalized.startsWith("../") || normalized.includes("/../")) {
+      throw new ValidationError("taskDirs must stay within the workspace root.");
+    }
+    return normalized;
+  });
+  if (validated.length === 0) {
+    throw new ValidationError("taskDirs must contain at least one directory.");
+  }
+  const existing = await readConfig(rootDir);
+  const validatedIgnorePaths = ignorePaths ?? existing.ignorePaths;
+  const payload = { version: 1, taskDirs: validated, ignorePaths: validatedIgnorePaths, order: existing.order };
+  await fs.writeFile(path.join(rootDir, CONFIG_FILE_NAME), `${JSON.stringify(payload, null, 2)}
+`, "utf8");
+  return payload;
+}
+async function listTasks(rootDir) {
+  const config = await readConfig(rootDir);
+  const files = await listMarkdownFiles(rootDir, config.taskDirs, config.ignorePaths);
+  const errors = [];
+  const tasks = await Promise.all(
+    files.map(async (relativePath) => {
+      try {
+        return await parseTask(rootDir, relativePath);
+      } catch (error) {
+        errors.push({
+          path: relativePath,
+          message: error instanceof Error ? error.message : "Unknown parse error"
+        });
+        return null;
+      }
+    })
+  );
+  const taskRecords = tasks.filter((task) => task !== null);
+  const { order, changed } = await reconcileOrder(
+    rootDir,
+    taskRecords.map((task) => task.path)
+  );
+  if (changed) {
+    await saveOrder(rootDir, order);
+  }
+  const orderIndex = new Map(order.map((item, index) => [item, index]));
+  taskRecords.sort((left, right) => {
+    const leftIndex = orderIndex.get(left.path) ?? Number.MAX_SAFE_INTEGER;
+    const rightIndex = orderIndex.get(right.path) ?? Number.MAX_SAFE_INTEGER;
+    return leftIndex - rightIndex || left.path.localeCompare(right.path);
+  });
+  return { tasks: taskRecords, errors };
+}
+async function ensureDirectoryForFile(rootDir, relativeFilePath) {
+  const normalized = ensureMarkdownExtension(normalizeRelativePath(relativeFilePath));
+  const absolutePath = path.join(rootDir, normalized);
+  const directory = path.dirname(absolutePath);
+  await fs.mkdir(directory, { recursive: true });
+  return normalized;
+}
+async function nextAvailablePath(rootDir, directory, title) {
+  const safeDirectory = directory ? normalizeRelativePath(directory) : "";
+  const slug = slugify(title);
+  const base = safeDirectory ? `${safeDirectory}/${slug}` : slug;
+  let attempt = 0;
+  while (true) {
+    const candidate = ensureMarkdownExtension(attempt === 0 ? base : `${base}-${attempt + 1}`);
+    try {
+      await fs.access(path.join(rootDir, candidate));
+      attempt += 1;
+    } catch {
+      return candidate;
+    }
+  }
+}
+async function createTask(rootDir, input) {
+  if (!input.title.trim()) {
+    throw new ValidationError("Title is required.");
+  }
+  const now = asUtcISOString(/* @__PURE__ */ new Date());
+  const relativePath = input.path?.trim() ? await ensureDirectoryForFile(rootDir, input.path) : await nextAvailablePath(rootDir, input.directory ?? "", input.title);
+  const absolutePath = path.join(rootDir, relativePath);
+  try {
+    await fs.access(absolutePath);
+  } catch (error) {
+    const maybeError = error;
+    if (maybeError.code === "ENOENT") {
+    } else if (maybeError.code) {
+      throw error;
+    } else {
+      throw new ValidationError("A task already exists at that path.");
+    }
+  }
+  const record = {
+    path: relativePath,
+    content: input.content ?? "",
+    raw: "",
+    normalized: false,
+    extraFrontmatter: input.extraFrontmatter ?? {},
+    frontmatter: {
+      title: input.title.trim(),
+      priority: input.priority ?? "MUST",
+      status: input.status ?? "TODO",
+      createdAt: now,
+      updatedAt: now
+    }
+  };
+  await fs.mkdir(path.dirname(absolutePath), { recursive: true });
+  await fs.writeFile(absolutePath, serializeTask(record), "utf8");
+  const current = await listTasks(rootDir);
+  await saveOrder(rootDir, current.tasks.map((task) => task.path).concat(relativePath));
+  return parseTask(rootDir, relativePath);
+}
+async function updateTask(rootDir, currentPath, input) {
+  const normalizedCurrentPath = ensureMarkdownExtension(normalizeRelativePath(currentPath));
+  const absoluteCurrentPath = path.join(rootDir, normalizedCurrentPath);
+  let existing;
+  try {
+    existing = await parseTask(rootDir, normalizedCurrentPath);
+  } catch (error) {
+    const maybeError = error;
+    if (maybeError.code === "ENOENT") {
+      throw new ConflictError("The task no longer exists.");
+    }
+    throw error;
+  }
+  if (input.baseUpdatedAt && existing.frontmatter.updatedAt !== input.baseUpdatedAt) {
+    throw new ConflictError("The task changed on disk. Reload before saving.");
+  }
+  const nextPath = input.path?.trim() ? await ensureDirectoryForFile(rootDir, input.path) : normalizedCurrentPath;
+  const absoluteNextPath = path.join(rootDir, nextPath);
+  if (nextPath !== normalizedCurrentPath) {
+    try {
+      await fs.access(absoluteNextPath);
+    } catch (error) {
+      const maybeError = error;
+      if (maybeError.code === "ENOENT") {
+      } else if (maybeError.code) {
+        throw error;
+      } else {
+        throw new ValidationError("A task already exists at the target path.");
+      }
+    }
+  }
+  const record = {
+    path: nextPath,
+    raw: existing.raw,
+    normalized: false,
+    content: input.content,
+    extraFrontmatter: input.extraFrontmatter ?? existing.extraFrontmatter,
+    frontmatter: {
+      title: input.title.trim(),
+      priority: input.priority,
+      status: input.status,
+      createdAt: existing.frontmatter.createdAt,
+      updatedAt: asUtcISOString(/* @__PURE__ */ new Date())
+    }
+  };
+  await fs.writeFile(absoluteCurrentPath, serializeTask(record), "utf8");
+  if (nextPath !== normalizedCurrentPath) {
+    await fs.mkdir(path.dirname(absoluteNextPath), { recursive: true });
+    await fs.rename(absoluteCurrentPath, absoluteNextPath);
+  }
+  const current = await listTasks(rootDir);
+  const updatedOrder = current.tasks.map((task) => task.path);
+  await saveOrder(rootDir, updatedOrder);
+  return parseTask(rootDir, nextPath);
+}
+async function deleteTask(rootDir, relativePath) {
+  const normalizedPath = ensureMarkdownExtension(normalizeRelativePath(relativePath));
+  const absolutePath = path.join(rootDir, normalizedPath);
+  try {
+    await fs.unlink(absolutePath);
+  } catch (error) {
+    const maybeError = error;
+    if (maybeError.code === "ENOENT") {
+      throw new ConflictError("The task no longer exists.");
+    }
+    throw error;
+  }
+  const current = await listTasks(rootDir);
+  await saveOrder(
+    rootDir,
+    current.tasks.map((task) => task.path)
+  );
+}
+async function patchTaskFields(rootDir, currentPath, input) {
+  const normalizedCurrentPath = ensureMarkdownExtension(normalizeRelativePath(currentPath));
+  const absoluteCurrentPath = path.join(rootDir, normalizedCurrentPath);
+  let existing;
+  try {
+    existing = await parseTask(rootDir, normalizedCurrentPath);
+  } catch (error) {
+    const maybeError = error;
+    if (maybeError.code === "ENOENT") {
+      throw new ConflictError("The task no longer exists.");
+    }
+    throw error;
+  }
+  const priority = input.priority && REQUIRED_PRIORITY.includes(input.priority) ? input.priority : existing.frontmatter.priority;
+  const status = input.status && REQUIRED_STATUS.includes(input.status) ? input.status : existing.frontmatter.status;
+  if (priority === existing.frontmatter.priority && status === existing.frontmatter.status) {
+    return existing;
+  }
+  const record = {
+    path: normalizedCurrentPath,
+    raw: existing.raw,
+    normalized: false,
+    content: existing.content,
+    extraFrontmatter: existing.extraFrontmatter,
+    frontmatter: {
+      ...existing.frontmatter,
+      priority,
+      status,
+      updatedAt: asUtcISOString(/* @__PURE__ */ new Date())
+    }
+  };
+  await fs.writeFile(absoluteCurrentPath, serializeTask(record), "utf8");
+  return parseTask(rootDir, normalizedCurrentPath);
+}
+function parseOrderPayload(input) {
+  if (!Array.isArray(input)) {
+    throw new ValidationError("Order payload must be an array.");
+  }
+  return input.map((item) => ensureMarkdownExtension(normalizeRelativePath(String(item))));
+}
+
+// src/server.ts
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = path2.dirname(__filename);
+function resolveClientDir(explicitClientDir) {
+  if (explicitClientDir === null) {
+    return null;
+  }
+  if (explicitClientDir) {
+    return explicitClientDir;
+  }
+  return path2.resolve(__dirname, "client");
+}
+function sendJsonError(reply, error) {
+  if (error instanceof ValidationError) {
+    reply.code(400).send({ error: error.message });
+    return;
+  }
+  if (error instanceof ConflictError) {
+    reply.code(409).send({ error: error.message });
+    return;
+  }
+  reply.code(500).send({ error: error instanceof Error ? error.message : "Internal server error" });
+}
+async function createServer(options) {
+  const app = Fastify({ logger: false });
+  const listeners = /* @__PURE__ */ new Set();
+  const clientDir = resolveClientDir(options.clientDir);
+  app.addHook("onClose", async () => {
+    for (const listener of listeners) {
+      listener.close();
+    }
+  });
+  app.get("/api/tasks", async () => listTasks(options.rootDir));
+  app.post("/api/tasks", async (request, reply) => {
+    try {
+      const task = await createTask(options.rootDir, request.body ?? {});
+      return reply.code(201).send(task);
+    } catch (error) {
+      sendJsonError(reply, error);
+    }
+  });
+  app.patch("/api/tasks/*", async (request, reply) => {
+    const currentPath = decodeURIComponent(request.params["*"] ?? "");
+    try {
+      const task = await updateTask(options.rootDir, currentPath, request.body ?? {});
+      return reply.send(task);
+    } catch (error) {
+      sendJsonError(reply, error);
+    }
+  });
+  app.delete("/api/tasks/*", async (request, reply) => {
+    const currentPath = decodeURIComponent(request.params["*"] ?? "");
+    try {
+      await deleteTask(options.rootDir, currentPath);
+      return reply.code(204).send();
+    } catch (error) {
+      sendJsonError(reply, error);
+    }
+  });
+  app.patch("/api/task-fields/*", async (request, reply) => {
+    const currentPath = decodeURIComponent(request.params["*"] ?? "");
+    try {
+      const task = await patchTaskFields(options.rootDir, currentPath, request.body ?? {});
+      return reply.send(task);
+    } catch (error) {
+      sendJsonError(reply, error);
+    }
+  });
+  app.put("/api/order", async (request, reply) => {
+    try {
+      const order = parseOrderPayload(request.body?.order ?? []);
+      await saveOrder(options.rootDir, order);
+      return reply.code(204).send();
+    } catch (error) {
+      sendJsonError(reply, error);
+    }
+  });
+  app.get("/api/config", async () => {
+    try {
+      return await readConfig(options.rootDir);
+    } catch (error) {
+      return { version: 1, taskDirs: ["."], order: [] };
+    }
+  });
+  app.put("/api/config", async (request, reply) => {
+    try {
+      const body = request.body;
+      const taskDirs = body?.taskDirs;
+      if (!Array.isArray(taskDirs) || taskDirs.some((item) => typeof item !== "string")) {
+        throw new ValidationError("taskDirs must be an array of strings.");
+      }
+      let ignorePaths;
+      if (body?.ignorePaths !== void 0) {
+        if (!Array.isArray(body.ignorePaths) || body.ignorePaths.some((item) => typeof item !== "string")) {
+          throw new ValidationError("ignorePaths must be an array of strings.");
+        }
+        ignorePaths = body.ignorePaths;
+      }
+      const config = await saveConfig(options.rootDir, taskDirs, ignorePaths);
+      return reply.send(config);
+    } catch (error) {
+      sendJsonError(reply, error);
+    }
+  });
+  app.get("/api/events", async (_request, reply) => {
+    reply.raw.writeHead(200, {
+      "Content-Type": "text/event-stream",
+      "Cache-Control": "no-cache, no-transform",
+      Connection: "keep-alive"
+    });
+    reply.raw.write("\n");
+    const listener = {
+      send(payload) {
+        reply.raw.write(`data: ${payload}
+
+`);
+      },
+      close() {
+        reply.raw.end();
+      }
+    };
+    listeners.add(listener);
+    reply.raw.on("close", () => {
+      listeners.delete(listener);
+    });
+    return reply.hijack();
+  });
+  const watcher = chokidar.watch(options.rootDir, {
+    ignoreInitial: true,
+    ignored: (watchPath) => watchPath.includes(`${path2.sep}.git`) || watchPath.includes(`${path2.sep}node_modules`)
+  });
+  watcher.on("all", (eventName, changedPath) => {
+    const isMarkdown = changedPath.endsWith(".md") || changedPath.endsWith(".markdown");
+    const isConfigFile = path2.basename(changedPath) === ".md-task-viewer.json";
+    if (!isMarkdown && !isConfigFile) {
+      return;
+    }
+    const payload = JSON.stringify({
+      type: "tasks-changed",
+      eventName,
+      path: path2.relative(options.rootDir, changedPath)
+    });
+    for (const listener of listeners) {
+      listener.send(payload);
+    }
+  });
+  app.addHook("onClose", async () => {
+    await watcher.close();
+  });
+  if (clientDir) {
+    await app.register(fastifyStatic, {
+      root: clientDir,
+      prefix: "/"
+    });
+    app.setNotFoundHandler(async (request, reply) => {
+      if (request.raw.url?.startsWith("/api/")) {
+        return reply.code(404).send({ error: "Not found" });
+      }
+      return reply.sendFile("index.html");
+    });
+  }
+  return app;
+}
+export {
+  createServer
+};
+//# sourceMappingURL=server.js.map