seekstone 0.4.1 → 0.6.0

package/dist/index.js

@@ -746,30 +746,181 @@ function updateCache(ctx2, path2, newContent, bodyStart) {
   }
 }
 
-// src/tools/read_note.ts
-import { readFile as readFile5 } from "fs/promises";
-import { join as join10 } from "path";
+// src/tools/periodic_note.ts
+import { access as access3, mkdir as mkdir3, readFile as readFile5, writeFile as writeFile5 } from "fs/promises";
+import { dirname as dirname3, join as join10 } from "path";
 import { z as z12 } from "zod";
-var ReadNoteInput = z12.object({
-  path: z12.string().describe('Vault-relative path to the note, e.g. "Daily Notes/2026-05-29.md".'),
-  section: z12.string().optional().describe("Return only this heading section (heading text, # prefix optional)."),
-  block: z12.string().optional().describe("Return only the block anchored by this id (^ prefix optional)."),
-  lines: z12.object({
-    from: z12.number().int().min(1).describe("First line (1-indexed, inclusive)."),
-    to: z12.number().int().min(1).optional().describe("Last line (1-indexed, inclusive). Defaults to end of file.")
+var PERIOD = z12.enum(["daily", "weekly", "monthly", "quarterly", "yearly"]);
+var DEFAULTS = {
+  daily: { folder: "", format: "YYYY-MM-DD", template: "" },
+  weekly: { folder: "", format: "gggg-[W]ww", template: "" },
+  monthly: { folder: "", format: "YYYY-MM", template: "" },
+  quarterly: { folder: "", format: "YYYY-[Q]Q", template: "" },
+  yearly: { folder: "", format: "YYYY", template: "" }
+};
+async function readJson(absPath) {
+  try {
+    return JSON.parse(await readFile5(absPath, "utf8"));
+  } catch {
+    return null;
+  }
+}
+async function resolveConfig(vaultRoot2, period) {
+  const defaults = DEFAULTS[period];
+  if (period === "daily") {
+    const cfg2 = await readJson(join10(vaultRoot2, ".obsidian", "daily-notes.json"));
+    return {
+      folder: cfg2?.folder ?? defaults.folder,
+      format: cfg2?.format ?? defaults.format,
+      template: cfg2?.template ?? defaults.template
+    };
+  }
+  const cfg = await readJson(
+    join10(vaultRoot2, ".obsidian", "plugins", "periodic-notes", "data.json")
+  );
+  const entry = cfg?.[period];
+  return {
+    folder: entry?.folder ?? defaults.folder,
+    format: entry?.format ?? defaults.format,
+    template: entry?.template ?? defaults.template
+  };
+}
+function isoWeekAndYear(date) {
+  const d = new Date(Date.UTC(date.getUTCFullYear(), date.getUTCMonth(), date.getUTCDate()));
+  const day = d.getUTCDay() || 7;
+  d.setUTCDate(d.getUTCDate() + 4 - day);
+  const jan1 = new Date(Date.UTC(d.getUTCFullYear(), 0, 1));
+  const week = Math.ceil(((d.getTime() - jan1.getTime()) / 864e5 + 1) / 7);
+  return { week, year: d.getUTCFullYear() };
+}
+function formatMomentDate(date, format) {
+  const year = date.getUTCFullYear();
+  const month = date.getUTCMonth() + 1;
+  const day = date.getUTCDate();
+  const quarter = Math.ceil(month / 3);
+  const { week: isoWeek, year: isoYear } = isoWeekAndYear(date);
+  const PLACEHOLDER = "\0";
+  const literals = [];
+  let s = format.replace(/\[([^\]]*)\]/g, (_, lit) => {
+    literals.push(lit);
+    return `${PLACEHOLDER}${literals.length - 1}${PLACEHOLDER}`;
+  });
+  s = s.replace(/gggg/g, String(isoYear).padStart(4, "0")).replace(/YYYY/g, String(year).padStart(4, "0")).replace(/YY/g, String(year).slice(-2)).replace(/MM/g, String(month).padStart(2, "0")).replace(/M/g, String(month)).replace(/DD/g, String(day).padStart(2, "0")).replace(/D/g, String(day)).replace(/ww/g, String(isoWeek).padStart(2, "0")).replace(/W/g, String(isoWeek)).replace(/Q/g, String(quarter));
+  return s.replace(
+    new RegExp(`${PLACEHOLDER}(\\d+)${PLACEHOLDER}`, "g"),
+    (_, i) => literals[+i] ?? ""
+  );
+}
+function resolveNotePath(cfg, date) {
+  const filename = `${formatMomentDate(date, cfg.format)}.md`;
+  return cfg.folder ? `${cfg.folder}/${filename}` : filename;
+}
+var GetPeriodicNoteInput = z12.object({
+  period: PERIOD.default("daily").describe(
+    "Period type: daily (default), weekly, monthly, quarterly, or yearly."
+  ),
+  date: z12.string().optional().describe("ISO date string (YYYY-MM-DD). Defaults to today when omitted."),
+  createIfMissing: z12.boolean().default(false).describe(
+    "Create the note from the configured template if it does not exist. Default false \u2014 reports missing without creating."
+  )
+});
+async function getPeriodicNote(ctx2, rawInput) {
+  const input = GetPeriodicNoteInput.parse(rawInput);
+  const date = input.date ? new Date(input.date) : /* @__PURE__ */ new Date();
+  const cfg = await resolveConfig(ctx2.vaultRoot, input.period);
+  const path2 = resolveNotePath(cfg, date);
+  const abs = join10(ctx2.vaultRoot, path2);
+  if (!abs.startsWith(ctx2.vaultRoot)) throw new Error(`Path outside vault: ${path2}`);
+  let existed = false;
+  try {
+    await access3(abs);
+    existed = true;
+  } catch {
+  }
+  if (existed) return { path: path2, existed: true, created: false };
+  if (!input.createIfMissing) return { path: path2, existed: false, created: false };
+  let body = "";
+  if (cfg.template) {
+    const templateAbs = join10(
+      ctx2.vaultRoot,
+      cfg.template.endsWith(".md") ? cfg.template : `${cfg.template}.md`
+    );
+    if (templateAbs.startsWith(ctx2.vaultRoot)) {
+      try {
+        body = await readFile5(templateAbs, "utf8");
+      } catch {
+      }
+    }
+  }
+  await mkdir3(dirname3(abs), { recursive: true });
+  await writeFile5(abs, body, "utf8");
+  upsertDoc(ctx2, buildDoc(path2, body));
+  return { path: path2, existed: false, created: true };
+}
+var AppendPeriodicNoteInput = z12.object({
+  period: PERIOD.default("daily").describe("Period type. Default: daily."),
+  date: z12.string().optional().describe("ISO date string (YYYY-MM-DD). Defaults to today."),
+  content: z12.string().min(1).describe("Text to append to the note body. Separated from existing content by a blank line."),
+  createIfMissing: z12.boolean().default(true).describe("Create the note if it does not exist before appending. Default true.")
+});
+async function appendPeriodicNote(ctx2, rawInput) {
+  const input = AppendPeriodicNoteInput.parse(rawInput);
+  const date = input.date ? new Date(input.date) : /* @__PURE__ */ new Date();
+  const cfg = await resolveConfig(ctx2.vaultRoot, input.period);
+  const path2 = resolveNotePath(cfg, date);
+  const abs = join10(ctx2.vaultRoot, path2);
+  if (!abs.startsWith(ctx2.vaultRoot)) throw new Error(`Path outside vault: ${path2}`);
+  let original = "";
+  try {
+    original = await readFile5(abs, "utf8");
+  } catch (err) {
+    if (err.code !== "ENOENT") throw err;
+    if (!input.createIfMissing) throw new Error(`Periodic note not found: ${path2}`);
+    await mkdir3(dirname3(abs), { recursive: true });
+    await writeFile5(abs, input.content, "utf8");
+    upsertDoc(ctx2, buildDoc(path2, input.content));
+    return { path: path2, bytesWritten: Buffer.byteLength(input.content, "utf8") };
+  }
+  const fm = parseFrontmatter(original);
+  const body = fm.body.endsWith("\n") ? fm.body : `${fm.body}
+`;
+  const separator = body.endsWith("\n\n") ? "" : "\n";
+  const newBody = `${body}${separator}${input.content}`;
+  const header = original.slice(0, fm.bodyStart);
+  const newRaw = `${header}${newBody}`;
+  await writeFile5(abs, newRaw, "utf8");
+  const cached = ctx2.notes.get(path2);
+  if (cached) {
+    cached.body = newBody;
+    cached.raw = newRaw;
+  }
+  return { path: path2, bytesWritten: Buffer.byteLength(newRaw, "utf8") };
+}
+
+// src/tools/read_note.ts
+import { readFile as readFile6 } from "fs/promises";
+import { join as join11 } from "path";
+import { z as z13 } from "zod";
+var ReadNoteInput = z13.object({
+  path: z13.string().describe('Vault-relative path to the note, e.g. "Daily Notes/2026-05-29.md".'),
+  section: z13.string().optional().describe("Return only this heading section (heading text, # prefix optional)."),
+  block: z13.string().optional().describe("Return only the block anchored by this id (^ prefix optional)."),
+  lines: z13.object({
+    from: z13.number().int().min(1).describe("First line (1-indexed, inclusive)."),
+    to: z13.number().int().min(1).optional().describe("Last line (1-indexed, inclusive). Defaults to end of file.")
   }).optional().describe("Return only this line range (1-indexed, inclusive)."),
-  includeFrontmatter: z12.boolean().optional().describe(
+  includeFrontmatter: z13.boolean().optional().describe(
     "Include frontmatter in span results. Default false for section/block spans. No effect on lines or whole-note reads."
   )
 }).refine((v) => [v.section, v.block, v.lines].filter((x) => x !== void 0).length <= 1, {
   message: "At most one of section, block, or lines may be specified."
 });
 async function readNote(ctx2, input) {
-  const absPath = join10(ctx2.vaultRoot, input.path);
+  const absPath = join11(ctx2.vaultRoot, input.path);
   if (!absPath.startsWith(ctx2.vaultRoot)) {
     throw new Error(`Path outside vault: ${input.path}`);
   }
-  const raw = await readFile5(absPath, "utf8");
+  const raw = await readFile6(absPath, "utf8");
   const noteBytes = Buffer.byteLength(raw, "utf8");
   if (input.section === void 0 && input.block === void 0 && input.lines === void 0) {
     return { path: input.path, content: raw, bytesReturned: noteBytes, noteBytes };
@@ -848,8 +999,101 @@ async function readNote(ctx2, input) {
   };
 }
 
+// src/tools/replace_in_note.ts
+import { readFile as readFile7, rename as rename3, writeFile as writeFile6 } from "fs/promises";
+import { join as join12 } from "path";
+import { z as z14 } from "zod";
+var ReplaceInNoteInput = z14.object({
+  path: z14.string().describe("Vault-relative path to the note."),
+  find: z14.string().min(1).describe("Text or pattern to find."),
+  replace: z14.string().describe("Replacement text. Supports $1, $2, \u2026 backreferences in regex mode."),
+  regex: z14.boolean().default(false).describe("Treat find as a regular expression."),
+  caseSensitive: z14.boolean().default(false).describe("Case-sensitive matching."),
+  wholeWord: z14.boolean().default(false).describe("Match whole words only (\\b word-boundary)."),
+  limit: z14.number().int().min(1).optional().describe("Maximum number of replacements. Omit to replace all."),
+  dryRun: z14.boolean().default(false).describe("If true, report matches without writing anything.")
+});
+function escapeRegex(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function buildRegex(find, opts) {
+  let pattern = opts.regex ? find : escapeRegex(find);
+  if (opts.wholeWord) pattern = `\\b(?:${pattern})\\b`;
+  const flags = `g${opts.caseSensitive ? "" : "i"}`;
+  return new RegExp(pattern, flags);
+}
+async function atomicWrite2(absPath, content) {
+  const tmpPath = `${absPath}.seekstone-replace-tmp`;
+  await writeFile6(tmpPath, content, "utf8");
+  await rename3(tmpPath, absPath);
+}
+async function replaceInNote(ctx2, input) {
+  const absPath = join12(ctx2.vaultRoot, input.path);
+  if (!absPath.startsWith(ctx2.vaultRoot)) {
+    throw new Error(`Path outside vault: ${input.path}`);
+  }
+  let re;
+  try {
+    re = buildRegex(input.find, {
+      regex: input.regex,
+      caseSensitive: input.caseSensitive,
+      wholeWord: input.wholeWord
+    });
+  } catch (err) {
+    throw new Error(`Invalid regex: ${err instanceof Error ? err.message : String(err)}`);
+  }
+  const raw = await readFile7(absPath, "utf8");
+  const fm = parseFrontmatter(raw);
+  const originalFmRegion = raw.slice(0, fm.bodyStart);
+  const body = raw.slice(fm.bodyStart);
+  const allMatches = [...body.matchAll(re)];
+  const toReplace = input.limit !== void 0 ? allMatches.slice(0, input.limit) : allMatches;
+  const matches = toReplace.map((m) => {
+    const fileOffset = fm.bodyStart + (m.index ?? 0);
+    const line = raw.slice(0, fileOffset).split("\n").length;
+    return { line, byteOffset: fileOffset };
+  });
+  if (input.dryRun || toReplace.length === 0) {
+    return {
+      path: input.path,
+      replacements: toReplace.length,
+      matches,
+      frontmatterUnchanged: true
+    };
+  }
+  const singleRe = new RegExp(re.source, re.flags.replace("g", ""));
+  let newBody = "";
+  let lastIndex = 0;
+  for (const m of toReplace) {
+    const matchIndex = m.index ?? 0;
+    newBody += body.slice(lastIndex, matchIndex);
+    newBody += input.regex ? m[0].replace(singleRe, input.replace) : input.replace;
+    lastIndex = matchIndex + m[0].length;
+  }
+  newBody += body.slice(lastIndex);
+  const newContent = `${originalFmRegion}${newBody}`;
+  await atomicWrite2(absPath, newContent);
+  const written = await readFile7(absPath, "utf8");
+  if (written.slice(0, originalFmRegion.length) !== originalFmRegion) {
+    throw new Error("Write-safety violation: frontmatter region changed unexpectedly");
+  }
+  const cached = ctx2.notes.get(input.path);
+  if (cached) {
+    cached.body = newBody;
+    cached.raw = newContent;
+    cached.sizeBytes = Buffer.byteLength(newContent, "utf8");
+  }
+  return {
+    path: input.path,
+    replacements: toReplace.length,
+    matches,
+    bytesWritten: Buffer.byteLength(newContent, "utf8"),
+    frontmatterUnchanged: true
+  };
+}
+
 // src/tools/search.ts
-import { z as z13 } from "zod";
+import { z as z15 } from "zod";
 
 // src/index/excerpt.ts
 function extractExcerpt(text, terms, maxLen = 200) {
@@ -876,11 +1120,11 @@ function truncate(s, max) {
 }
 
 // src/tools/search.ts
-var SearchInput = z13.object({
-  query: z13.string().min(1).describe("Search query. Supports fuzzy matching and prefix search."),
-  limit: z13.number().int().min(1).max(50).default(10).describe("Maximum number of results to return."),
-  folder: z13.string().optional().describe("Restrict results to notes under this vault-relative folder prefix."),
-  tag: z13.string().optional().describe("Restrict results to notes containing this tag.")
+var SearchInput = z15.object({
+  query: z15.string().min(1).describe("Search query. Supports fuzzy matching and prefix search."),
+  limit: z15.number().int().min(1).max(50).default(10).describe("Maximum number of results to return."),
+  folder: z15.string().optional().describe("Restrict results to notes under this vault-relative folder prefix."),
+  tag: z15.string().optional().describe("Restrict results to notes containing this tag.")
 });
 function search(ctx2, input) {
   const results = ctx2.index.search(input.query, {
@@ -924,7 +1168,9 @@ var META_KEYS = [
   "overwrite",
   "pattern",
   "minCount",
-  "sort"
+  "sort",
+  "period",
+  "date"
 ];
 function safeMeta(args) {
   if (typeof args !== "object" || args === null) return {};
@@ -1036,18 +1282,40 @@ async function run(ctx2, name, args) {
       const result = getLinks(ctx2, input);
       return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
     }
+    case "replace_in_note": {
+      const input = ReplaceInNoteInput.parse(args);
+      const result = await replaceInNote(ctx2, input);
+      return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+    }
+    case "get_periodic_note": {
+      const input = GetPeriodicNoteInput.parse(args);
+      const result = await getPeriodicNote(ctx2, input);
+      return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+    }
+    case "append_periodic_note": {
+      const input = AppendPeriodicNoteInput.parse(args);
+      const result = await appendPeriodicNote(ctx2, input);
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Appended ${result.bytesWritten} bytes to ${result.path}.`
+          }
+        ]
+      };
+    }
     default:
       throw new Error(`Unknown tool: ${name}`);
   }
 }
 
 // src/index/build.ts
-import { readFile as readFile6 } from "fs/promises";
+import { readFile as readFile8 } from "fs/promises";
 import { basename as basename2, extname as extname3 } from "path";
 
 // ../core/src/walk.ts
 import { stat } from "fs/promises";
-import { extname as extname2, join as join11, relative, sep } from "path";
+import { extname as extname2, join as join13, relative, sep } from "path";
 import fg from "fast-glob";
 var IMAGE_EXTS = /* @__PURE__ */ new Set([".png", ".jpg", ".jpeg", ".gif", ".webp", ".svg", ".bmp", ".heic"]);
 var VIDEO_EXTS = /* @__PURE__ */ new Set([".mp4", ".mov", ".webm", ".mkv", ".avi"]);
@@ -1124,7 +1392,7 @@ async function buildIndex(vaultRoot2) {
   await Promise.all(
     noteEntries.map(async (entry) => {
       try {
-        const raw = await readFile6(entry.absPath, "utf8");
+        const raw = await readFile8(entry.absPath, "utf8");
         const fm = parseFrontmatter(raw);
         const inlineTags = extractInlineTags(fm.body);
         const fmTags = frontmatterTags(fm.data);
@@ -1176,8 +1444,8 @@ function buildBacklinks(notes2) {
 
 // src/init.ts
 import { execFileSync } from "child_process";
-import { access as access3, copyFile, mkdir as mkdir3, readFile as readFile7, readdir, stat as stat2, writeFile as writeFile5 } from "fs/promises";
-import path, { dirname as dirname3, join as join12 } from "path";
+import { access as access4, copyFile, mkdir as mkdir4, readFile as readFile9, readdir, stat as stat2, writeFile as writeFile7 } from "fs/promises";
+import path, { dirname as dirname4, join as join14 } from "path";
 function parseInitArgs(argv) {
   const opts = { write: false, client: "desktop" };
   for (let i = 0; i < argv.length; i++) {
@@ -1265,7 +1533,7 @@ async function validateVault(vaultPath) {
     return { ok: false, error: `Path does not exist: ${vaultPath}` };
   }
   try {
-    await access3(join12(vaultPath, ".obsidian"));
+    await access4(join14(vaultPath, ".obsidian"));
   } catch {
     return {
       ok: false,
@@ -1285,7 +1553,7 @@ async function countMarkdown(root) {
     }
     for (const e of entries) {
       if (e.name.startsWith(".")) continue;
-      const full = join12(dir, e.name);
+      const full = join14(dir, e.name);
       if (e.isDirectory()) await walk(full);
       else if (e.name.endsWith(".md")) count++;
     }
@@ -1294,7 +1562,7 @@ async function countMarkdown(root) {
   return count;
 }
 async function runInit(opts, deps) {
-  const rf = deps.readFile ?? readFile7;
+  const rf = deps.readFile ?? readFile9;
   let vaultPath = opts.vault ?? deps.env.SEEKSTONE_VAULT;
   if (!vaultPath) {
     const registryPath = obsidianRegistryPath(deps.platform, {
@@ -1423,12 +1691,12 @@ async function runInit(opts, deps) {
   }
   const merged = mergeSeekstoneConfig(existing, vaultPath);
   let backupPath;
-  await mkdir3(dirname3(configPath), { recursive: true });
+  await mkdir4(dirname4(configPath), { recursive: true });
   if (existingRaw !== null) {
     backupPath = `${configPath}.backup-${deps.timestamp}`;
     await copyFile(configPath, backupPath);
   }
-  await writeFile5(configPath, `${JSON.stringify(merged, null, 2)}
+  await writeFile7(configPath, `${JSON.stringify(merged, null, 2)}
 `, "utf8");
   out.push(
     `\u2713 Patched ${configPath}`,
@@ -1500,7 +1768,7 @@ function createLogger(opts = {}) {
       );
     }
   }
-  function writeFile6(record) {
+  function writeFile8(record) {
     if (!fileOk || filePath === void 0) return;
     const line = `${JSON.stringify(record)}
 `;
@@ -1522,7 +1790,7 @@ function createLogger(opts = {}) {
     const f = fields ?? {};
     stderr(`${lvl.toUpperCase().padEnd(5)} ${ts} ${msg}${fmtFields(f)}
 `);
-    writeFile6({ t: ts, level: lvl, msg, ...f });
+    writeFile8({ t: ts, level: lvl, msg, ...f });
   }
   return {
     level,
@@ -1534,8 +1802,8 @@ function createLogger(opts = {}) {
 }
 
 // src/watcher.ts
-import { readFile as readFile8 } from "fs/promises";
-import { join as join13, relative as relative2, sep as sep2 } from "path";
+import { readFile as readFile10 } from "fs/promises";
+import { join as join15, relative as relative2, sep as sep2 } from "path";
 import chokidar from "chokidar";
 function removeNoteBacklinks(ctx2, relPath) {
   const oldDoc = ctx2.notes.get(relPath);
@@ -1572,7 +1840,7 @@ function startWatcher(ctx2, log2, opts) {
   const toRel = (abs) => relative2(ctx2.vaultRoot, abs).split(sep2).join("/");
   async function upsert(relPath, op) {
     try {
-      const raw = await readFile8(join13(ctx2.vaultRoot, relPath), "utf8");
+      const raw = await readFile10(join15(ctx2.vaultRoot, relPath), "utf8");
       removeNoteBacklinks(ctx2, relPath);
       upsertDoc(ctx2, buildDoc(relPath, raw));
       addNoteBacklinks(ctx2, relPath, raw);
@@ -1590,6 +1858,7 @@ function startWatcher(ctx2, log2, opts) {
   }
   const onUpsert = (op) => (abs) => {
     const relPath = toRel(abs);
+    opts?.onRawEvent?.(op, abs, relPath);
     if (relPath.endsWith(".md")) void upsert(relPath, op);
   };
   const watcher2 = chokidar.watch(ctx2.vaultRoot, {
@@ -1608,6 +1877,7 @@ function startWatcher(ctx2, log2, opts) {
   });
   watcher2.on("add", onUpsert("add")).on("change", onUpsert("change")).on("unlink", (abs) => {
     const relPath = toRel(abs);
+    opts?.onRawEvent?.("unlink", abs, relPath);
     if (relPath.endsWith(".md")) remove(relPath);
   });
   const ready = new Promise((resolve) => {
@@ -1620,7 +1890,7 @@ function startWatcher(ctx2, log2, opts) {
 }
 
 // src/index.ts
-var VERSION = true ? "0.4.1" : "0.0.0-dev";
+var VERSION = true ? "0.6.0" : "0.0.0-dev";
 var intent = parseCliIntent(process.argv.slice(2));
 if (intent === "version") {
   process.stdout.write(`${VERSION}
@@ -1897,6 +2167,92 @@ server.setRequestHandler(ListToolsRequestSchema, async () => ({
         },
         required: ["path"]
       }
+    },
+    {
+      name: "replace_in_note",
+      description: "Find and replace text within a note body. Supports literal and regex search, case sensitivity, whole-word matching, and a replacement limit. Frontmatter is never touched. Use dryRun to preview matches before writing.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          path: { type: "string", description: "Vault-relative path to the note." },
+          find: { type: "string", description: "Text or pattern to find." },
+          replace: {
+            type: "string",
+            description: "Replacement text. Supports $1, $2, \u2026 backreferences in regex mode."
+          },
+          regex: {
+            type: "boolean",
+            description: "Treat find as a regular expression. Default false."
+          },
+          caseSensitive: {
+            type: "boolean",
+            description: "Case-sensitive matching. Default false."
+          },
+          wholeWord: {
+            type: "boolean",
+            description: "Match whole words only (\\b boundary). Default false."
+          },
+          limit: {
+            type: "number",
+            description: "Maximum number of replacements. Omit to replace all."
+          },
+          dryRun: {
+            type: "boolean",
+            description: "If true, report matches without writing. Default false."
+          }
+        },
+        required: ["path", "find", "replace"]
+      }
+    },
+    {
+      name: "get_periodic_note",
+      description: "Get the path and existence status of a periodic note (daily, weekly, monthly, quarterly, or yearly) for a given date. Reads folder/format config from .obsidian/daily-notes.json (daily) or the periodic-notes plugin data.json. Optionally creates the note from the configured template if it is missing.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          period: {
+            type: "string",
+            enum: ["daily", "weekly", "monthly", "quarterly", "yearly"],
+            description: "Period type. Default: daily."
+          },
+          date: {
+            type: "string",
+            description: "ISO date string (YYYY-MM-DD). Defaults to today when omitted."
+          },
+          createIfMissing: {
+            type: "boolean",
+            description: "Create the note from the configured template if it does not exist. Default false."
+          }
+        },
+        required: []
+      }
+    },
+    {
+      name: "append_periodic_note",
+      description: "Append text to a periodic note (daily, weekly, monthly, quarterly, or yearly). Preserves existing frontmatter exactly. Creates the note first (from template if configured) when createIfMissing is true (default).",
+      inputSchema: {
+        type: "object",
+        properties: {
+          period: {
+            type: "string",
+            enum: ["daily", "weekly", "monthly", "quarterly", "yearly"],
+            description: "Period type. Default: daily."
+          },
+          date: {
+            type: "string",
+            description: "ISO date string (YYYY-MM-DD). Defaults to today when omitted."
+          },
+          content: {
+            type: "string",
+            description: "Text to append to the note body."
+          },
+          createIfMissing: {
+            type: "boolean",
+            description: "Create the note if it does not exist before appending. Default true."
+          }
+        },
+        required: ["content"]
+      }
     }
   ]
 }));
@@ -1906,7 +2262,7 @@ server.setRequestHandler(CallToolRequestSchema, async (req) => {
 });
 var transport = new StdioServerTransport();
 await server.connect(transport);
-log.info("ready", { tools: 13, transport: "stdio" });
+log.info("ready", { tools: 16, transport: "stdio" });
 process.stderr.write(
   `seekstone: add to Claude Desktop:
 ${JSON.stringify(