@velvetmonkey/flywheel-crank 0.1.0

package/dist/index.js

@@ -0,0 +1,1195 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+
+// src/tools/mutations.ts
+import { z } from "zod";
+
+// src/core/writer.ts
+import fs from "fs/promises";
+import path from "path";
+import matter from "gray-matter";
+
+// src/core/constants.ts
+var HEADING_REGEX = /^(#{1,6})\s+(.+)$/;
+
+// src/core/writer.ts
+function extractHeadings(content) {
+  const lines = content.split("\n");
+  const headings = [];
+  let inCodeBlock = false;
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (line.trim().startsWith("```")) {
+      inCodeBlock = !inCodeBlock;
+      continue;
+    }
+    if (inCodeBlock)
+      continue;
+    const match = line.match(HEADING_REGEX);
+    if (match) {
+      headings.push({
+        level: match[1].length,
+        text: match[2].trim(),
+        line: i
+      });
+    }
+  }
+  return headings;
+}
+function findSection(content, sectionName) {
+  const headings = extractHeadings(content);
+  const lines = content.split("\n");
+  const normalizedSearch = sectionName.replace(/^#+\s*/, "").trim().toLowerCase();
+  const headingIndex = headings.findIndex(
+    (h) => h.text.toLowerCase() === normalizedSearch
+  );
+  if (headingIndex === -1)
+    return null;
+  const targetHeading = headings[headingIndex];
+  const startLine = targetHeading.line;
+  const contentStartLine = startLine + 1;
+  let endLine = lines.length - 1;
+  for (let i = headingIndex + 1; i < headings.length; i++) {
+    if (headings[i].level <= targetHeading.level) {
+      endLine = headings[i].line - 1;
+      break;
+    }
+  }
+  return {
+    name: targetHeading.text,
+    level: targetHeading.level,
+    startLine,
+    endLine,
+    contentStartLine
+  };
+}
+function formatContent(content, format) {
+  const trimmed = content.trim();
+  switch (format) {
+    case "plain":
+      return trimmed;
+    case "bullet":
+      return `- ${trimmed}`;
+    case "task":
+      return `- [ ] ${trimmed}`;
+    case "numbered":
+      return `1. ${trimmed}`;
+    case "timestamp-bullet": {
+      const now = /* @__PURE__ */ new Date();
+      const hours = String(now.getHours()).padStart(2, "0");
+      const minutes = String(now.getMinutes()).padStart(2, "0");
+      return `- **${hours}:${minutes}** ${trimmed}`;
+    }
+    default:
+      return trimmed;
+  }
+}
+function insertInSection(content, section, newContent, position) {
+  const lines = content.split("\n");
+  const formattedContent = newContent.trim();
+  if (position === "prepend") {
+    lines.splice(section.contentStartLine, 0, formattedContent);
+  } else {
+    let insertLine = section.endLine + 1;
+    if (section.contentStartLine <= section.endLine) {
+      insertLine = section.endLine + 1;
+    } else {
+      insertLine = section.contentStartLine;
+    }
+    lines.splice(insertLine, 0, formattedContent);
+  }
+  return lines.join("\n");
+}
+function validatePath(vaultPath2, notePath) {
+  const resolvedVault = path.resolve(vaultPath2);
+  const resolvedNote = path.resolve(vaultPath2, notePath);
+  return resolvedNote.startsWith(resolvedVault);
+}
+async function readVaultFile(vaultPath2, notePath) {
+  if (!validatePath(vaultPath2, notePath)) {
+    throw new Error("Invalid path: path traversal not allowed");
+  }
+  const fullPath = path.join(vaultPath2, notePath);
+  const rawContent = await fs.readFile(fullPath, "utf-8");
+  const parsed = matter(rawContent);
+  return {
+    content: parsed.content,
+    frontmatter: parsed.data,
+    rawContent
+  };
+}
+async function writeVaultFile(vaultPath2, notePath, content, frontmatter) {
+  if (!validatePath(vaultPath2, notePath)) {
+    throw new Error("Invalid path: path traversal not allowed");
+  }
+  const fullPath = path.join(vaultPath2, notePath);
+  const output = matter.stringify(content, frontmatter);
+  await fs.writeFile(fullPath, output, "utf-8");
+}
+function removeFromSection(content, section, pattern, mode = "first", useRegex = false) {
+  const lines = content.split("\n");
+  const removedLines = [];
+  const indicesToRemove = [];
+  for (let i = section.contentStartLine; i <= section.endLine; i++) {
+    const line = lines[i];
+    let matches = false;
+    if (useRegex) {
+      const regex = new RegExp(pattern);
+      matches = regex.test(line);
+    } else {
+      matches = line.includes(pattern);
+    }
+    if (matches) {
+      indicesToRemove.push(i);
+      removedLines.push(line);
+      if (mode === "first")
+        break;
+    }
+  }
+  if (mode === "last" && indicesToRemove.length > 1) {
+    const lastIndex = indicesToRemove[indicesToRemove.length - 1];
+    const lastLine = removedLines[removedLines.length - 1];
+    indicesToRemove.length = 0;
+    removedLines.length = 0;
+    indicesToRemove.push(lastIndex);
+    removedLines.push(lastLine);
+  }
+  const sortedIndices = [...indicesToRemove].sort((a, b) => b - a);
+  for (const idx of sortedIndices) {
+    lines.splice(idx, 1);
+  }
+  return {
+    content: lines.join("\n"),
+    removedCount: indicesToRemove.length,
+    removedLines
+  };
+}
+function replaceInSection(content, section, search, replacement, mode = "first", useRegex = false) {
+  const lines = content.split("\n");
+  const originalLines = [];
+  const newLines = [];
+  const indicesToReplace = [];
+  for (let i = section.contentStartLine; i <= section.endLine; i++) {
+    const line = lines[i];
+    let matches = false;
+    if (useRegex) {
+      const regex = new RegExp(search);
+      matches = regex.test(line);
+    } else {
+      matches = line.includes(search);
+    }
+    if (matches) {
+      indicesToReplace.push(i);
+      originalLines.push(line);
+      if (mode === "first")
+        break;
+    }
+  }
+  if (mode === "last" && indicesToReplace.length > 1) {
+    const lastIndex = indicesToReplace[indicesToReplace.length - 1];
+    const lastLine = originalLines[originalLines.length - 1];
+    indicesToReplace.length = 0;
+    originalLines.length = 0;
+    indicesToReplace.push(lastIndex);
+    originalLines.push(lastLine);
+  }
+  for (const idx of indicesToReplace) {
+    const originalLine = lines[idx];
+    let newLine;
+    if (useRegex) {
+      const regex = new RegExp(search, "g");
+      newLine = originalLine.replace(regex, replacement);
+    } else {
+      newLine = originalLine.split(search).join(replacement);
+    }
+    lines[idx] = newLine;
+    newLines.push(newLine);
+  }
+  return {
+    content: lines.join("\n"),
+    replacedCount: indicesToReplace.length,
+    originalLines,
+    newLines
+  };
+}
+
+// src/core/git.ts
+import { simpleGit, CheckRepoActions } from "simple-git";
+import path2 from "path";
+async function isGitRepo(vaultPath2) {
+  try {
+    const git = simpleGit(vaultPath2);
+    const isRepo = await git.checkIsRepo(CheckRepoActions.IS_REPO_ROOT);
+    return isRepo;
+  } catch {
+    return false;
+  }
+}
+async function commitChange(vaultPath2, filePath, messagePrefix) {
+  try {
+    const git = simpleGit(vaultPath2);
+    const isRepo = await isGitRepo(vaultPath2);
+    if (!isRepo) {
+      return {
+        success: false,
+        error: "Not a git repository"
+      };
+    }
+    await git.add(filePath);
+    const fileName = path2.basename(filePath);
+    const commitMessage = `${messagePrefix} Update ${fileName}`;
+    const result = await git.commit(commitMessage);
+    return {
+      success: true,
+      hash: result.commit
+    };
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+async function getLastCommit(vaultPath2) {
+  try {
+    const git = simpleGit(vaultPath2);
+    const isRepo = await isGitRepo(vaultPath2);
+    if (!isRepo) {
+      return null;
+    }
+    const log = await git.log({ maxCount: 1 });
+    if (!log.latest) {
+      return null;
+    }
+    return {
+      hash: log.latest.hash,
+      message: log.latest.message,
+      date: log.latest.date,
+      author: log.latest.author_name
+    };
+  } catch {
+    return null;
+  }
+}
+async function undoLastCommit(vaultPath2) {
+  try {
+    const git = simpleGit(vaultPath2);
+    const isRepo = await isGitRepo(vaultPath2);
+    if (!isRepo) {
+      return {
+        success: false,
+        message: "Not a git repository"
+      };
+    }
+    const lastCommit = await getLastCommit(vaultPath2);
+    if (!lastCommit) {
+      return {
+        success: false,
+        message: "No commits to undo"
+      };
+    }
+    await git.reset(["--soft", "HEAD~1"]);
+    return {
+      success: true,
+      message: `Undone commit: ${lastCommit.message}`,
+      undoneCommit: lastCommit
+    };
+  } catch (error) {
+    return {
+      success: false,
+      message: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+
+// src/tools/mutations.ts
+import fs2 from "fs/promises";
+import path3 from "path";
+function registerMutationTools(server2, vaultPath2, autoCommit2) {
+  server2.tool(
+    "vault_add_to_section",
+    "Add content to a specific section in a markdown note",
+    {
+      path: z.string().describe('Vault-relative path to the note (e.g., "daily-notes/2026-01-28.md")'),
+      section: z.string().describe('Heading text to add to (e.g., "Log" or "## Log")'),
+      content: z.string().describe("Content to add to the section"),
+      position: z.enum(["append", "prepend"]).default("append").describe("Where to insert content"),
+      format: z.enum(["plain", "bullet", "task", "numbered", "timestamp-bullet"]).default("plain").describe("How to format the content")
+    },
+    async ({ path: notePath, section, content, position, format }) => {
+      try {
+        const fullPath = path3.join(vaultPath2, notePath);
+        try {
+          await fs2.access(fullPath);
+        } catch {
+          const result2 = {
+            success: false,
+            message: `File not found: ${notePath}`,
+            path: notePath
+          };
+          return { content: [{ type: "text", text: JSON.stringify(result2, null, 2) }] };
+        }
+        const { content: fileContent, frontmatter } = await readVaultFile(vaultPath2, notePath);
+        const sectionBoundary = findSection(fileContent, section);
+        if (!sectionBoundary) {
+          const result2 = {
+            success: false,
+            message: `Section not found: ${section}`,
+            path: notePath
+          };
+          return { content: [{ type: "text", text: JSON.stringify(result2, null, 2) }] };
+        }
+        const formattedContent = formatContent(content, format);
+        const updatedContent = insertInSection(
+          fileContent,
+          sectionBoundary,
+          formattedContent,
+          position
+        );
+        await writeVaultFile(vaultPath2, notePath, updatedContent, frontmatter);
+        let gitCommit;
+        let gitError;
+        if (autoCommit2) {
+          const gitResult = await commitChange(vaultPath2, notePath, "[Crank:Add]");
+          if (gitResult.success) {
+            gitCommit = gitResult.hash;
+          } else {
+            gitError = gitResult.error;
+          }
+        }
+        const preview = formattedContent;
+        const result = {
+          success: true,
+          message: `Added content to section "${sectionBoundary.name}" in ${notePath}`,
+          path: notePath,
+          preview,
+          gitCommit,
+          gitError
+        };
+        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+      } catch (error) {
+        const result = {
+          success: false,
+          message: `Failed to add content: ${error instanceof Error ? error.message : String(error)}`,
+          path: notePath
+        };
+        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+      }
+    }
+  );
+  server2.tool(
+    "vault_remove_from_section",
+    "Remove content from a specific section in a markdown note",
+    {
+      path: z.string().describe("Vault-relative path to the note"),
+      section: z.string().describe('Heading text to remove from (e.g., "Log" or "## Log")'),
+      pattern: z.string().describe("Text or pattern to match for removal"),
+      mode: z.enum(["first", "last", "all"]).default("first").describe("Which matches to remove"),
+      useRegex: z.boolean().default(false).describe("Treat pattern as regex")
+    },
+    async ({ path: notePath, section, pattern, mode, useRegex }) => {
+      try {
+        const fullPath = path3.join(vaultPath2, notePath);
+        try {
+          await fs2.access(fullPath);
+        } catch {
+          const result2 = {
+            success: false,
+            message: `File not found: ${notePath}`,
+            path: notePath
+          };
+          return { content: [{ type: "text", text: JSON.stringify(result2, null, 2) }] };
+        }
+        const { content: fileContent, frontmatter } = await readVaultFile(vaultPath2, notePath);
+        const sectionBoundary = findSection(fileContent, section);
+        if (!sectionBoundary) {
+          const result2 = {
+            success: false,
+            message: `Section not found: ${section}`,
+            path: notePath
+          };
+          return { content: [{ type: "text", text: JSON.stringify(result2, null, 2) }] };
+        }
+        const removeResult = removeFromSection(
+          fileContent,
+          sectionBoundary,
+          pattern,
+          mode,
+          useRegex
+        );
+        if (removeResult.removedCount === 0) {
+          const result2 = {
+            success: false,
+            message: `No content matching "${pattern}" found in section "${sectionBoundary.name}"`,
+            path: notePath
+          };
+          return { content: [{ type: "text", text: JSON.stringify(result2, null, 2) }] };
+        }
+        await writeVaultFile(vaultPath2, notePath, removeResult.content, frontmatter);
+        let gitCommit;
+        let gitError;
+        if (autoCommit2) {
+          const gitResult = await commitChange(vaultPath2, notePath, "[Crank:Remove]");
+          if (gitResult.success) {
+            gitCommit = gitResult.hash;
+          } else {
+            gitError = gitResult.error;
+          }
+        }
+        const result = {
+          success: true,
+          message: `Removed ${removeResult.removedCount} line(s) from section "${sectionBoundary.name}" in ${notePath}`,
+          path: notePath,
+          preview: removeResult.removedLines.join("\n"),
+          gitCommit,
+          gitError
+        };
+        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+      } catch (error) {
+        const result = {
+          success: false,
+          message: `Failed to remove content: ${error instanceof Error ? error.message : String(error)}`,
+          path: notePath
+        };
+        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+      }
+    }
+  );
+  server2.tool(
+    "vault_replace_in_section",
+    "Replace content in a specific section in a markdown note",
+    {
+      path: z.string().describe("Vault-relative path to the note"),
+      section: z.string().describe('Heading text to search in (e.g., "Log" or "## Log")'),
+      search: z.string().describe("Text or pattern to search for"),
+      replacement: z.string().describe("Text to replace with"),
+      mode: z.enum(["first", "last", "all"]).default("first").describe("Which matches to replace"),
+      useRegex: z.boolean().default(false).describe("Treat search as regex")
+    },
+    async ({ path: notePath, section, search, replacement, mode, useRegex }) => {
+      try {
+        const fullPath = path3.join(vaultPath2, notePath);
+        try {
+          await fs2.access(fullPath);
+        } catch {
+          const result2 = {
+            success: false,
+            message: `File not found: ${notePath}`,
+            path: notePath
+          };
+          return { content: [{ type: "text", text: JSON.stringify(result2, null, 2) }] };
+        }
+        const { content: fileContent, frontmatter } = await readVaultFile(vaultPath2, notePath);
+        const sectionBoundary = findSection(fileContent, section);
+        if (!sectionBoundary) {
+          const result2 = {
+            success: false,
+            message: `Section not found: ${section}`,
+            path: notePath
+          };
+          return { content: [{ type: "text", text: JSON.stringify(result2, null, 2) }] };
+        }
+        const replaceResult = replaceInSection(
+          fileContent,
+          sectionBoundary,
+          search,
+          replacement,
+          mode,
+          useRegex
+        );
+        if (replaceResult.replacedCount === 0) {
+          const result2 = {
+            success: false,
+            message: `No content matching "${search}" found in section "${sectionBoundary.name}"`,
+            path: notePath
+          };
+          return { content: [{ type: "text", text: JSON.stringify(result2, null, 2) }] };
+        }
+        await writeVaultFile(vaultPath2, notePath, replaceResult.content, frontmatter);
+        let gitCommit;
+        let gitError;
+        if (autoCommit2) {
+          const gitResult = await commitChange(vaultPath2, notePath, "[Crank:Replace]");
+          if (gitResult.success) {
+            gitCommit = gitResult.hash;
+          } else {
+            gitError = gitResult.error;
+          }
+        }
+        const previewLines = replaceResult.originalLines.map(
+          (orig, i) => `- ${orig}
++ ${replaceResult.newLines[i]}`
+        );
+        const result = {
+          success: true,
+          message: `Replaced ${replaceResult.replacedCount} occurrence(s) in section "${sectionBoundary.name}" in ${notePath}`,
+          path: notePath,
+          preview: previewLines.join("\n"),
+          gitCommit,
+          gitError
+        };
+        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+      } catch (error) {
+        const result = {
+          success: false,
+          message: `Failed to replace content: ${error instanceof Error ? error.message : String(error)}`,
+          path: notePath
+        };
+        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+      }
+    }
+  );
+  console.error("[Crank] Mutation tools registered (vault_add_to_section, vault_remove_from_section, vault_replace_in_section)");
+}
+
+// src/tools/tasks.ts
+import { z as z2 } from "zod";
+import fs3 from "fs/promises";
+import path4 from "path";
+var TASK_REGEX = /^(\s*)-\s*\[([ xX])\]\s*(.*)$/;
+function findTasks(content, section) {
+  const lines = content.split("\n");
+  const tasks = [];
+  const startLine = section?.contentStartLine ?? 0;
+  const endLine = section?.endLine ?? lines.length - 1;
+  for (let i = startLine; i <= endLine; i++) {
+    const line = lines[i];
+    const match = line.match(TASK_REGEX);
+    if (match) {
+      tasks.push({
+        line: i,
+        text: match[3].trim(),
+        completed: match[2].toLowerCase() === "x",
+        indent: match[1],
+        rawLine: line
+      });
+    }
+  }
+  return tasks;
+}
+function toggleTask(content, lineNumber) {
+  const lines = content.split("\n");
+  if (lineNumber < 0 || lineNumber >= lines.length) {
+    return null;
+  }
+  const line = lines[lineNumber];
+  const match = line.match(TASK_REGEX);
+  if (!match) {
+    return null;
+  }
+  const wasCompleted = match[2].toLowerCase() === "x";
+  const newState = !wasCompleted;
+  if (wasCompleted) {
+    lines[lineNumber] = line.replace(/\[[ xX]\]/, "[ ]");
+  } else {
+    lines[lineNumber] = line.replace(/\[[ xX]\]/, "[x]");
+  }
+  return {
+    content: lines.join("\n"),
+    newState
+  };
+}
+function registerTaskTools(server2, vaultPath2, autoCommit2) {
+  server2.tool(
+    "vault_toggle_task",
+    "Toggle a task checkbox between checked and unchecked",
+    {
+      path: z2.string().describe("Vault-relative path to the note"),
+      task: z2.string().describe("Task text to find (partial match supported)"),
+      section: z2.string().optional().describe("Optional: limit search to this section")
+    },
+    async ({ path: notePath, task, section }) => {
+      try {
+        const fullPath = path4.join(vaultPath2, notePath);
+        try {
+          await fs3.access(fullPath);
+        } catch {
+          const result2 = {
+            success: false,
+            message: `File not found: ${notePath}`,
+            path: notePath
+          };
+          return { content: [{ type: "text", text: JSON.stringify(result2, null, 2) }] };
+        }
+        const { content: fileContent, frontmatter } = await readVaultFile(vaultPath2, notePath);
+        let sectionBoundary;
+        if (section) {
+          const found = findSection(fileContent, section);
+          if (!found) {
+            const result2 = {
+              success: false,
+              message: `Section not found: ${section}`,
+              path: notePath
+            };
+            return { content: [{ type: "text", text: JSON.stringify(result2, null, 2) }] };
+          }
+          sectionBoundary = found;
+        }
+        const tasks = findTasks(fileContent, sectionBoundary);
+        const searchLower = task.toLowerCase();
+        const matchingTask = tasks.find(
+          (t) => t.text.toLowerCase().includes(searchLower)
+        );
+        if (!matchingTask) {
+          const result2 = {
+            success: false,
+            message: `No task found matching "${task}"${section ? ` in section "${section}"` : ""}`,
+            path: notePath
+          };
+          return { content: [{ type: "text", text: JSON.stringify(result2, null, 2) }] };
+        }
+        const toggleResult = toggleTask(fileContent, matchingTask.line);
+        if (!toggleResult) {
+          const result2 = {
+            success: false,
+            message: "Failed to toggle task",
+            path: notePath
+          };
+          return { content: [{ type: "text", text: JSON.stringify(result2, null, 2) }] };
+        }
+        await writeVaultFile(vaultPath2, notePath, toggleResult.content, frontmatter);
+        let gitCommit;
+        let gitError;
+        if (autoCommit2) {
+          const gitResult = await commitChange(vaultPath2, notePath, "[Crank:Task]");
+          if (gitResult.success) {
+            gitCommit = gitResult.hash;
+          } else {
+            gitError = gitResult.error;
+          }
+        }
+        const newStatus = toggleResult.newState ? "completed" : "incomplete";
+        const checkbox = toggleResult.newState ? "[x]" : "[ ]";
+        const result = {
+          success: true,
+          message: `Toggled task to ${newStatus} in ${notePath}`,
+          path: notePath,
+          preview: `${checkbox} ${matchingTask.text}`,
+          gitCommit,
+          gitError
+        };
+        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+      } catch (error) {
+        const result = {
+          success: false,
+          message: `Failed to toggle task: ${error instanceof Error ? error.message : String(error)}`,
+          path: notePath
+        };
+        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+      }
+    }
+  );
+  server2.tool(
+    "vault_add_task",
+    "Add a new task to a section in a markdown note",
+    {
+      path: z2.string().describe("Vault-relative path to the note"),
+      section: z2.string().describe("Section to add the task to"),
+      task: z2.string().describe("Task text (without checkbox)"),
+      position: z2.enum(["append", "prepend"]).default("append").describe("Where to add the task"),
+      completed: z2.boolean().default(false).describe("Whether the task should start as completed")
+    },
+    async ({ path: notePath, section, task, position, completed }) => {
+      try {
+        const fullPath = path4.join(vaultPath2, notePath);
+        try {
+          await fs3.access(fullPath);
+        } catch {
+          const result2 = {
+            success: false,
+            message: `File not found: ${notePath}`,
+            path: notePath
+          };
+          return { content: [{ type: "text", text: JSON.stringify(result2, null, 2) }] };
+        }
+        const { content: fileContent, frontmatter } = await readVaultFile(vaultPath2, notePath);
+        const sectionBoundary = findSection(fileContent, section);
+        if (!sectionBoundary) {
+          const result2 = {
+            success: false,
+            message: `Section not found: ${section}`,
+            path: notePath
+          };
+          return { content: [{ type: "text", text: JSON.stringify(result2, null, 2) }] };
+        }
+        const checkbox = completed ? "[x]" : "[ ]";
+        const taskLine = `- ${checkbox} ${task.trim()}`;
+        const updatedContent = insertInSection(
+          fileContent,
+          sectionBoundary,
+          taskLine,
+          position
+        );
+        await writeVaultFile(vaultPath2, notePath, updatedContent, frontmatter);
+        let gitCommit;
+        let gitError;
+        if (autoCommit2) {
+          const gitResult = await commitChange(vaultPath2, notePath, "[Crank:Task]");
+          if (gitResult.success) {
+            gitCommit = gitResult.hash;
+          } else {
+            gitError = gitResult.error;
+          }
+        }
+        const result = {
+          success: true,
+          message: `Added task to section "${sectionBoundary.name}" in ${notePath}`,
+          path: notePath,
+          preview: taskLine,
+          gitCommit,
+          gitError
+        };
+        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+      } catch (error) {
+        const result = {
+          success: false,
+          message: `Failed to add task: ${error instanceof Error ? error.message : String(error)}`,
+          path: notePath
+        };
+        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+      }
+    }
+  );
+  console.error("[Crank] Task tools registered (vault_toggle_task, vault_add_task)");
+}
+
+// src/tools/frontmatter.ts
+import { z as z3 } from "zod";
+import fs4 from "fs/promises";
+import path5 from "path";
+function registerFrontmatterTools(server2, vaultPath2, autoCommit2) {
+  server2.tool(
+    "vault_update_frontmatter",
+    "Update frontmatter fields in a note (merge with existing frontmatter)",
+    {
+      path: z3.string().describe("Vault-relative path to the note"),
+      frontmatter: z3.record(z3.any()).describe("Frontmatter fields to update (JSON object)")
+    },
+    async ({ path: notePath, frontmatter: updates }) => {
+      try {
+        const fullPath = path5.join(vaultPath2, notePath);
+        try {
+          await fs4.access(fullPath);
+        } catch {
+          const result2 = {
+            success: false,
+            message: `File not found: ${notePath}`,
+            path: notePath
+          };
+          return { content: [{ type: "text", text: JSON.stringify(result2, null, 2) }] };
+        }
+        const { content, frontmatter } = await readVaultFile(vaultPath2, notePath);
+        const updatedFrontmatter = { ...frontmatter, ...updates };
+        await writeVaultFile(vaultPath2, notePath, content, updatedFrontmatter);
+        let gitCommit;
+        let gitError;
+        if (autoCommit2) {
+          const gitResult = await commitChange(vaultPath2, notePath, "[Crank:FM]");
+          if (gitResult.success) {
+            gitCommit = gitResult.hash;
+          } else {
+            gitError = gitResult.error;
+          }
+        }
+        const updatedKeys = Object.keys(updates);
+        const preview = updatedKeys.map((k) => `${k}: ${JSON.stringify(updates[k])}`).join("\n");
+        const result = {
+          success: true,
+          message: `Updated ${updatedKeys.length} frontmatter field(s) in ${notePath}`,
+          path: notePath,
+          preview,
+          gitCommit,
+          gitError
+        };
+        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+      } catch (error) {
+        const result = {
+          success: false,
+          message: `Failed to update frontmatter: ${error instanceof Error ? error.message : String(error)}`,
+          path: notePath
+        };
+        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+      }
+    }
+  );
+  server2.tool(
+    "vault_add_frontmatter_field",
+    "Add a new frontmatter field to a note (only if it doesn't exist)",
+    {
+      path: z3.string().describe("Vault-relative path to the note"),
+      key: z3.string().describe("Field name to add"),
+      value: z3.any().describe("Field value (string, number, boolean, array, object)")
+    },
+    async ({ path: notePath, key, value }) => {
+      try {
+        const fullPath = path5.join(vaultPath2, notePath);
+        try {
+          await fs4.access(fullPath);
+        } catch {
+          const result2 = {
+            success: false,
+            message: `File not found: ${notePath}`,
+            path: notePath
+          };
+          return { content: [{ type: "text", text: JSON.stringify(result2, null, 2) }] };
+        }
+        const { content, frontmatter } = await readVaultFile(vaultPath2, notePath);
+        if (key in frontmatter) {
+          const result2 = {
+            success: false,
+            message: `Field "${key}" already exists. Use vault_update_frontmatter to modify existing fields.`,
+            path: notePath
+          };
+          return { content: [{ type: "text", text: JSON.stringify(result2, null, 2) }] };
+        }
+        const updatedFrontmatter = { ...frontmatter, [key]: value };
+        await writeVaultFile(vaultPath2, notePath, content, updatedFrontmatter);
+        let gitCommit;
+        let gitError;
+        if (autoCommit2) {
+          const gitResult = await commitChange(vaultPath2, notePath, "[Crank:FM]");
+          if (gitResult.success) {
+            gitCommit = gitResult.hash;
+          } else {
+            gitError = gitResult.error;
+          }
+        }
+        const result = {
+          success: true,
+          message: `Added frontmatter field "${key}" to ${notePath}`,
+          path: notePath,
+          preview: `${key}: ${JSON.stringify(value)}`,
+          gitCommit,
+          gitError
+        };
+        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+      } catch (error) {
+        const result = {
+          success: false,
+          message: `Failed to add frontmatter field: ${error instanceof Error ? error.message : String(error)}`,
+          path: notePath
+        };
+        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+      }
+    }
+  );
+  console.error("[Crank] Frontmatter tools registered (vault_update_frontmatter, vault_add_frontmatter_field)");
+}
+
+// src/tools/notes.ts
+import { z as z4 } from "zod";
+import fs5 from "fs/promises";
+import path6 from "path";
+function registerNoteTools(server2, vaultPath2, autoCommit2) {
+  server2.tool(
+    "vault_create_note",
+    "Create a new note in the vault with optional frontmatter and content",
+    {
+      path: z4.string().describe('Vault-relative path for the new note (e.g., "daily-notes/2026-01-28.md")'),
+      content: z4.string().default("").describe("Initial content for the note"),
+      frontmatter: z4.record(z4.any()).default({}).describe("Frontmatter fields (JSON object)"),
+      overwrite: z4.boolean().default(false).describe("If true, overwrite existing file")
+    },
+    async ({ path: notePath, content, frontmatter, overwrite }) => {
+      try {
+        if (!validatePath(vaultPath2, notePath)) {
+          const result2 = {
+            success: false,
+            message: "Invalid path: path traversal not allowed",
+            path: notePath
+          };
+          return { content: [{ type: "text", text: JSON.stringify(result2, null, 2) }] };
+        }
+        const fullPath = path6.join(vaultPath2, notePath);
+        try {
+          await fs5.access(fullPath);
+          if (!overwrite) {
+            const result2 = {
+              success: false,
+              message: `File already exists: ${notePath}. Use overwrite=true to replace.`,
+              path: notePath
+            };
+            return { content: [{ type: "text", text: JSON.stringify(result2, null, 2) }] };
+          }
+        } catch {
+        }
+        const dir = path6.dirname(fullPath);
+        await fs5.mkdir(dir, { recursive: true });
+        await writeVaultFile(vaultPath2, notePath, content, frontmatter);
+        let gitCommit;
+        let gitError;
+        if (autoCommit2) {
+          const gitResult = await commitChange(vaultPath2, notePath, "[Crank:Create]");
+          if (gitResult.success) {
+            gitCommit = gitResult.hash;
+          } else {
+            gitError = gitResult.error;
+          }
+        }
+        const result = {
+          success: true,
+          message: `Created note: ${notePath}`,
+          path: notePath,
+          preview: `Frontmatter fields: ${Object.keys(frontmatter).join(", ") || "none"}
+Content length: ${content.length} chars`,
+          gitCommit,
+          gitError
+        };
+        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+      } catch (error) {
+        const result = {
+          success: false,
+          message: `Failed to create note: ${error instanceof Error ? error.message : String(error)}`,
+          path: notePath
+        };
+        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+      }
+    }
+  );
+  server2.tool(
+    "vault_delete_note",
+    "Delete a note from the vault",
+    {
+      path: z4.string().describe("Vault-relative path to the note to delete"),
+      confirm: z4.boolean().default(false).describe("Must be true to confirm deletion")
+    },
+    async ({ path: notePath, confirm }) => {
+      try {
+        if (!confirm) {
+          const result2 = {
+            success: false,
+            message: "Deletion requires explicit confirmation (confirm=true)",
+            path: notePath
+          };
+          return { content: [{ type: "text", text: JSON.stringify(result2, null, 2) }] };
+        }
+        if (!validatePath(vaultPath2, notePath)) {
+          const result2 = {
+            success: false,
+            message: "Invalid path: path traversal not allowed",
+            path: notePath
+          };
+          return { content: [{ type: "text", text: JSON.stringify(result2, null, 2) }] };
+        }
+        const fullPath = path6.join(vaultPath2, notePath);
+        try {
+          await fs5.access(fullPath);
+        } catch {
+          const result2 = {
+            success: false,
+            message: `File not found: ${notePath}`,
+            path: notePath
+          };
+          return { content: [{ type: "text", text: JSON.stringify(result2, null, 2) }] };
+        }
+        await fs5.unlink(fullPath);
+        let gitCommit;
+        let gitError;
+        if (autoCommit2) {
+          const gitResult = await commitChange(vaultPath2, notePath, "[Crank:Delete]");
+          if (gitResult.success) {
+            gitCommit = gitResult.hash;
+          } else {
+            gitError = gitResult.error;
+          }
+        }
+        const result = {
+          success: true,
+          message: `Deleted note: ${notePath}`,
+          path: notePath,
+          gitCommit,
+          gitError
+        };
+        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+      } catch (error) {
+        const result = {
+          success: false,
+          message: `Failed to delete note: ${error instanceof Error ? error.message : String(error)}`,
+          path: notePath
+        };
+        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+      }
+    }
+  );
+  console.error("[Crank] Note tools registered (vault_create_note, vault_delete_note)");
+}
+
+// src/tools/system.ts
+import { z as z5 } from "zod";
+import fs6 from "fs/promises";
+import path7 from "path";
+function registerSystemTools(server2, vaultPath2, autoCommit2) {
+  server2.tool(
+    "vault_list_sections",
+    "List all sections (headings) in a markdown note",
+    {
+      path: z5.string().describe("Vault-relative path to the note"),
+      minLevel: z5.number().min(1).max(6).default(1).describe("Minimum heading level to include"),
+      maxLevel: z5.number().min(1).max(6).default(6).describe("Maximum heading level to include")
+    },
+    async ({ path: notePath, minLevel, maxLevel }) => {
+      try {
+        if (!validatePath(vaultPath2, notePath)) {
+          const result2 = {
+            success: false,
+            message: "Invalid path: path traversal not allowed",
+            path: notePath
+          };
+          return { content: [{ type: "text", text: JSON.stringify(result2, null, 2) }] };
+        }
+        const fullPath = path7.join(vaultPath2, notePath);
+        try {
+          await fs6.access(fullPath);
+        } catch {
+          const result2 = {
+            success: false,
+            message: `File not found: ${notePath}`,
+            path: notePath
+          };
+          return { content: [{ type: "text", text: JSON.stringify(result2, null, 2) }] };
+        }
+        const { content: fileContent } = await readVaultFile(vaultPath2, notePath);
+        const headings = extractHeadings(fileContent);
+        const filteredHeadings = headings.filter(
+          (h) => h.level >= minLevel && h.level <= maxLevel
+        );
+        const sections = filteredHeadings.map((h) => ({
+          level: h.level,
+          name: h.text,
+          line: h.line + 1
+          // 1-indexed for user display
+        }));
+        const result = {
+          success: true,
+          message: `Found ${sections.length} section(s) in ${notePath}`,
+          path: notePath,
+          sections
+        };
+        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+      } catch (error) {
+        const result = {
+          success: false,
+          message: `Failed to list sections: ${error instanceof Error ? error.message : String(error)}`,
+          path: notePath
+        };
+        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+      }
+    }
+  );
+  server2.tool(
+    "vault_undo_last_mutation",
+    "Undo the last git commit (typically the last Crank mutation). Performs a soft reset.",
+    {
+      confirm: z5.boolean().default(false).describe("Must be true to confirm undo operation")
+    },
+    async ({ confirm }) => {
+      try {
+        if (!confirm) {
+          const lastCommit = await getLastCommit(vaultPath2);
+          if (!lastCommit) {
+            const result3 = {
+              success: false,
+              message: "No commits found to undo",
+              path: ""
+            };
+            return { content: [{ type: "text", text: JSON.stringify(result3, null, 2) }] };
+          }
+          const result2 = {
+            success: false,
+            message: `Undo requires confirmation (confirm=true). Would undo: "${lastCommit.message}"`,
+            path: "",
+            preview: `Commit: ${lastCommit.hash.substring(0, 7)}
+Message: ${lastCommit.message}
+Date: ${lastCommit.date}`
+          };
+          return { content: [{ type: "text", text: JSON.stringify(result2, null, 2) }] };
+        }
+        if (!autoCommit2) {
+          const result2 = {
+            success: false,
+            message: 'Undo is only available when AUTO_COMMIT is enabled. Set AUTO_COMMIT="true" in .mcp.json to enable automatic git commits for each mutation.',
+            path: ""
+          };
+          return { content: [{ type: "text", text: JSON.stringify(result2, null, 2) }] };
+        }
+        const isRepo = await isGitRepo(vaultPath2);
+        if (!isRepo) {
+          const result2 = {
+            success: false,
+            message: "Vault is not a git repository. Undo is only available for git-tracked vaults.",
+            path: ""
+          };
+          return { content: [{ type: "text", text: JSON.stringify(result2, null, 2) }] };
+        }
+        const undoResult = await undoLastCommit(vaultPath2);
+        if (!undoResult.success) {
+          const result2 = {
+            success: false,
+            message: undoResult.message,
+            path: ""
+          };
+          return { content: [{ type: "text", text: JSON.stringify(result2, null, 2) }] };
+        }
+        const result = {
+          success: true,
+          message: undoResult.message,
+          path: "",
+          preview: undoResult.undoneCommit ? `Commit: ${undoResult.undoneCommit.hash.substring(0, 7)}
+Message: ${undoResult.undoneCommit.message}` : void 0
+        };
+        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+      } catch (error) {
+        const result = {
+          success: false,
+          message: `Failed to undo: ${error instanceof Error ? error.message : String(error)}`,
+          path: ""
+        };
+        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+      }
+    }
+  );
+  console.error("[Crank] System tools registered (vault_list_sections, vault_undo_last_mutation)");
+}
+
+// src/core/vaultRoot.ts
+import * as fs7 from "fs";
+import * as path8 from "path";
+var VAULT_MARKERS = [".obsidian", ".claude"];
+function findVaultRoot(startPath) {
+  let current = path8.resolve(startPath || process.cwd());
+  while (true) {
+    for (const marker of VAULT_MARKERS) {
+      const markerPath = path8.join(current, marker);
+      if (fs7.existsSync(markerPath) && fs7.statSync(markerPath).isDirectory()) {
+        return current;
+      }
+    }
+    const parent = path8.dirname(current);
+    if (parent === current) {
+      return startPath || process.cwd();
+    }
+    current = parent;
+  }
+}
+
+// src/index.ts
+var server = new McpServer({
+  name: "flywheel-crank",
+  version: "0.1.0"
+});
+var vaultPath = process.env.PROJECT_PATH || findVaultRoot();
+var autoCommit = process.env.AUTO_COMMIT === "true";
+console.error(`[Crank] Starting Flywheel Crank MCP server`);
+console.error(`[Crank] Vault path: ${vaultPath}`);
+console.error(`[Crank] Auto-commit: ${autoCommit}`);
+registerMutationTools(server, vaultPath, autoCommit);
+registerTaskTools(server, vaultPath, autoCommit);
+registerFrontmatterTools(server, vaultPath, autoCommit);
+registerNoteTools(server, vaultPath, autoCommit);
+registerSystemTools(server, vaultPath, autoCommit);
+var transport = new StdioServerTransport();
+await server.connect(transport);
+console.error(`[Crank] Flywheel Crank MCP server started successfully`);