@gmickel/gno 0.34.0 → 0.35.0

package/src/core/sections.ts

@@ -0,0 +1,62 @@
+/**
+ * Shared section extraction and anchor helpers.
+ *
+ * Browser-safe.
+ *
+ * @module src/core/sections
+ */
+
+export interface DocumentSection {
+  anchor: string;
+  level: number;
+  line: number;
+  title: string;
+}
+
+const HEADING_REGEX = /^(#{1,6})\s+(.+?)\s*#*\s*$/u;
+
+export function slugifySectionTitle(title: string): string {
+  return (
+    title
+      .normalize("NFC")
+      .toLowerCase()
+      .trim()
+      .replaceAll(/[^\p{L}\p{N}\s-]/gu, "")
+      .replaceAll(/\s+/g, "-")
+      .replaceAll(/-+/g, "-")
+      .replace(/^-|-$/g, "") || "section"
+  );
+}
+
+export function extractSections(content: string): DocumentSection[] {
+  const sections: DocumentSection[] = [];
+  const counts = new Map<string, number>();
+  const lines = content.split("\n");
+
+  for (const [index, line] of lines.entries()) {
+    const match = HEADING_REGEX.exec(line);
+    if (!match) {
+      continue;
+    }
+
+    const level = match[1]?.length ?? 0;
+    const title = match[2]?.trim() ?? "";
+    if (!title) {
+      continue;
+    }
+
+    const baseAnchor = slugifySectionTitle(title);
+    const count = (counts.get(baseAnchor) ?? 0) + 1;
+    counts.set(baseAnchor, count);
+    const anchor = count === 1 ? baseAnchor : `${baseAnchor}-${count}`;
+
+    sections.push({
+      anchor,
+      level,
+      line: index + 1,
+      title,
+    });
+  }
+
+  return sections;
+}

package/src/core/validation.ts

@@ -9,7 +9,7 @@ import { realpath } from "node:fs/promises";
 // node:os for homedir (no Bun os utils)
 import { homedir } from "node:os";
 // node:path for path utils (no Bun path utils)
-import { isAbsolute, join, normalize, sep } from "node:path";
+import { isAbsolute, join, posix as pathPosix } from "node:path";
 
 import { toAbsolutePath } from "../config/paths";
 
@@ -48,8 +48,9 @@ export function validateRelPath(relPath: string): string {
     throw new Error("relPath contains invalid characters");
   }
 
-  const normalized = normalize(relPath);
-  const segments = normalized.split(sep);
+  const normalizedInput = relPath.replaceAll("\\", "/");
+  const normalized = pathPosix.normalize(normalizedInput);
+  const segments = normalized.split("/");
   if (segments.includes("..")) {
     throw new Error("relPath cannot escape collection root");
   }

package/src/mcp/tools/capture.ts

@@ -15,6 +15,15 @@ import { buildUri } from "../../app/constants";
 import { MCP_ERRORS } from "../../core/errors";
 import { withWriteLock } from "../../core/file-lock";
 import { atomicWrite } from "../../core/file-ops";
+import {
+  resolveNoteCreatePlan,
+  type NoteCollisionPolicy,
+} from "../../core/note-creation";
+import {
+  getNotePreset,
+  resolveNotePreset,
+  type NotePresetId,
+} from "../../core/note-presets";
 import { normalizeTag, validateTag } from "../../core/tags";
 import {
   normalizeCollectionName,
@@ -27,10 +36,13 @@ import { runTool, type ToolResult } from "./index";
 
 interface CaptureInput {
   collection: string;
-  content: string;
+  content?: string;
   title?: string;
   path?: string;
   overwrite?: boolean;
+  folderPath?: string;
+  collisionPolicy?: NoteCollisionPolicy;
+  presetId?: NotePresetId;
   tags?: string[];
 }
 
@@ -123,17 +135,46 @@ export function handleCapture(
           );
         }
 
+        if (args.presetId && !getNotePreset(args.presetId)) {
+          throw new Error(
+            `${MCP_ERRORS.INVALID_INPUT.code}: Unknown presetId: ${args.presetId}`
+          );
+        }
+
+        const existingDocs = await ctx.store.listDocuments(collectionName);
+        if (!existingDocs.ok) {
+          throw new Error(existingDocs.error.message);
+        }
+
         let relPath: string;
-        if (args.path) {
-          try {
-            relPath = ensureMarkdownExtension(validateRelPath(args.path));
-          } catch (error) {
-            const message =
-              error instanceof Error ? error.message : String(error);
-            throw new Error(`${MCP_ERRORS.INVALID_PATH.code}: ${message}`);
+        try {
+          const plan = resolveNoteCreatePlan(
+            {
+              collection: collection.name,
+              relPath: args.path
+                ? ensureMarkdownExtension(validateRelPath(args.path))
+                : undefined,
+              title:
+                args.title?.trim() ||
+                generateFilename(args.title, args.content ?? "").replace(
+                  /\.md$/u,
+                  ""
+                ),
+              folderPath: args.folderPath,
+              collisionPolicy: args.collisionPolicy,
+            },
+            existingDocs.value.map((doc) => doc.relPath)
+          );
+          if (plan.openedExisting) {
+            throw new Error(
+              `${MCP_ERRORS.CONFLICT.code}: Existing note resolution is not supported through gno_capture yet`
+            );
           }
-        } else {
-          relPath = generateFilename(args.title, args.content);
+          relPath = plan.relPath;
+        } catch (error) {
+          const message =
+            error instanceof Error ? error.message : String(error);
+          throw new Error(`${MCP_ERRORS.INVALID_PATH.code}: ${message}`);
         }
 
         assertNotSensitive(relPath);
@@ -164,12 +205,30 @@ export function handleCapture(
         }
 
         // Update frontmatter with tags for Markdown files
-        let contentToWrite = args.content;
+        const resolvedPreset = resolveNotePreset({
+          presetId: args.presetId,
+          title:
+            args.title?.trim() ||
+            relPath
+              .split("/")
+              .pop()
+              ?.replace(/\.[^.]+$/u, "") ||
+            "Untitled",
+          tags: normalizedTags,
+          body: args.content,
+        });
+        let contentToWrite =
+          resolvedPreset?.content ??
+          args.content ??
+          `# ${args.title?.trim() || "Untitled"}\n`;
         const isMarkdown =
           relPath.endsWith(".md") || relPath.endsWith(".markdown");
         if (isMarkdown && normalizedTags.length > 0) {
           // Use shared utility that handles all frontmatter edge cases
-          contentToWrite = updateFrontmatterTags(args.content, normalizedTags);
+          contentToWrite = updateFrontmatterTags(
+            contentToWrite,
+            normalizedTags
+          );
         }
 
         await mkdir(dirname(absPath), { recursive: true });

package/src/mcp/tools/index.ts

@@ -32,6 +32,12 @@ import { handleSearch } from "./search";
 import { handleStatus } from "./status";
 import { handleSync } from "./sync";
 import { handleVsearch } from "./vsearch";
+import {
+  handleCreateFolder,
+  handleDuplicateNote,
+  handleMoveNote,
+  handleRenameNote,
+} from "./workspace-write";
 
 // ─────────────────────────────────────────────────────────────────────────────
 // Shared Helpers
@@ -121,7 +127,12 @@ const captureInputSchema = z.object({
     .string()
     .min(1, "Collection cannot be empty")
     .describe("Target collection name (must already exist)"),
-  content: z.string().describe("Document content (markdown or plain text)"),
+  content: z
+    .string()
+    .optional()
+    .describe(
+      "Document content (markdown or plain text). Optional when presetId provides a scaffold."
+    ),
   title: z
     .string()
     .optional()
@@ -132,6 +143,25 @@ const captureInputSchema = z.object({
     .describe(
       "Relative path within collection (e.g. 'notes/meeting.md'). Auto-generated from title if omitted"
     ),
+  folderPath: z
+    .string()
+    .optional()
+    .describe("Optional folder path within the collection"),
+  collisionPolicy: z
+    .enum(["error", "open_existing", "create_with_suffix"])
+    .optional()
+    .describe("How to handle name collisions"),
+  presetId: z
+    .enum([
+      "blank",
+      "project-note",
+      "research-note",
+      "decision-note",
+      "prompt-pattern",
+      "source-summary",
+    ])
+    .optional()
+    .describe("Optional note preset scaffold"),
   overwrite: z
     .boolean()
     .default(false)
@@ -200,6 +230,29 @@ const removeCollectionInputSchema = z.object({
     .describe("Collection name to remove"),
 });
 
+const createFolderInputSchema = z.object({
+  collection: z.string().min(1, "Collection cannot be empty"),
+  name: z.string().min(1, "Folder name cannot be empty"),
+  parentPath: z.string().optional(),
+});
+
+const renameNoteInputSchema = z.object({
+  ref: z.string().min(1, "ref cannot be empty"),
+  name: z.string().min(1, "name cannot be empty"),
+});
+
+const moveNoteInputSchema = z.object({
+  ref: z.string().min(1, "ref cannot be empty"),
+  folderPath: z.string().min(1, "folderPath cannot be empty"),
+  name: z.string().optional(),
+});
+
+const duplicateNoteInputSchema = z.object({
+  ref: z.string().min(1, "ref cannot be empty"),
+  folderPath: z.string().optional(),
+  name: z.string().optional(),
+});
+
 const vsearchInputSchema = z.object({
   query: z
     .string()
@@ -764,6 +817,34 @@ export function registerTools(server: McpServer, ctx: ToolContext): void {
       removeCollectionInputSchema.shape,
       (args) => handleRemoveCollection(args, ctx)
     );
+
+    server.tool(
+      "gno_create_folder",
+      "Create a folder inside an existing collection.",
+      createFolderInputSchema.shape,
+      (args) => handleCreateFolder(args, ctx)
+    );
+
+    server.tool(
+      "gno_rename_note",
+      "Rename an editable note in place.",
+      renameNoteInputSchema.shape,
+      (args) => handleRenameNote(args, ctx)
+    );
+
+    server.tool(
+      "gno_move_note",
+      "Move an editable note to another folder in the same collection.",
+      moveNoteInputSchema.shape,
+      (args) => handleMoveNote(args, ctx)
+    );
+
+    server.tool(
+      "gno_duplicate_note",
+      "Duplicate an editable note into the current or another folder.",
+      duplicateNoteInputSchema.shape,
+      (args) => handleDuplicateNote(args, ctx)
+    );
   }
 
   server.tool(

package/src/mcp/tools/workspace-write.ts

@@ -0,0 +1,321 @@
+/**
+ * MCP workspace write tools for note/file operations.
+ *
+ * @module src/mcp/tools/workspace-write
+ */
+
+// node:fs/promises for mkdir (no Bun equivalent for structure ops)
+import { mkdir } from "node:fs/promises";
+// node:path for dirname/join (no Bun path utils)
+import { dirname, join } from "node:path";
+
+import type { Collection } from "../../config/types";
+import type { ToolContext } from "../server";
+
+import { getDocumentCapabilities } from "../../core/document-capabilities";
+import { MCP_ERRORS } from "../../core/errors";
+import { withWriteLock } from "../../core/file-lock";
+import {
+  copyFilePath,
+  createFolderPath,
+  renameFilePath,
+} from "../../core/file-ops";
+import {
+  buildRefactorWarnings,
+  planCreateFolder,
+  planDuplicateRefactor,
+  planMoveRefactor,
+  planRenameRefactor,
+} from "../../core/file-refactors";
+import { defaultSyncService } from "../../ingestion";
+import { runTool, type ToolResult } from "./index";
+
+interface CreateFolderInput {
+  collection: string;
+  name: string;
+  parentPath?: string;
+}
+
+interface RenameNoteInput {
+  ref: string;
+  name: string;
+}
+
+interface MoveNoteInput {
+  ref: string;
+  folderPath: string;
+  name?: string;
+}
+
+interface DuplicateNoteInput {
+  ref: string;
+  folderPath?: string;
+  name?: string;
+}
+
+function resolveCollection(ctx: ToolContext, name: string): Collection {
+  const normalized = name.trim().toLowerCase();
+  const collection = ctx.collections.find((entry) => entry.name === normalized);
+  if (!collection) {
+    throw new Error(
+      `${MCP_ERRORS.NOT_FOUND.code}: Collection not found: ${name}`
+    );
+  }
+  return collection;
+}
+
+async function resolveDocByRef(ctx: ToolContext, ref: string) {
+  const trimmed = ref.trim();
+  if (!trimmed) {
+    throw new Error(`${MCP_ERRORS.INVALID_INPUT.code}: ref cannot be empty`);
+  }
+
+  if (trimmed.startsWith("#")) {
+    const result = await ctx.store.getDocumentByDocid(trimmed);
+    if (!result.ok) {
+      throw new Error(result.error.message);
+    }
+    if (!result.value) {
+      throw new Error(
+        `${MCP_ERRORS.NOT_FOUND.code}: Document not found: ${ref}`
+      );
+    }
+    return result.value;
+  }
+
+  if (trimmed.startsWith("gno://")) {
+    const result = await ctx.store.getDocumentByUri(trimmed);
+    if (!result.ok) {
+      throw new Error(result.error.message);
+    }
+    if (!result.value) {
+      throw new Error(
+        `${MCP_ERRORS.NOT_FOUND.code}: Document not found: ${ref}`
+      );
+    }
+    return result.value;
+  }
+
+  const slash = trimmed.indexOf("/");
+  if (slash === -1) {
+    throw new Error(
+      `${MCP_ERRORS.INVALID_INPUT.code}: ref must be #docid, gno:// URI, or collection/path`
+    );
+  }
+
+  const collection = trimmed.slice(0, slash).toLowerCase();
+  const relPath = trimmed.slice(slash + 1);
+  const result = await ctx.store.getDocument(collection, relPath);
+  if (!result.ok) {
+    throw new Error(result.error.message);
+  }
+  if (!result.value) {
+    throw new Error(`${MCP_ERRORS.NOT_FOUND.code}: Document not found: ${ref}`);
+  }
+  return result.value;
+}
+
+async function getRefactorSnapshot(ctx: ToolContext, documentId: number) {
+  const [linksResult, backlinksResult] = await Promise.all([
+    ctx.store.getLinksForDoc(documentId),
+    ctx.store.getBacklinksForDoc(documentId),
+  ]);
+  if (!linksResult.ok) {
+    throw new Error(linksResult.error.message);
+  }
+  if (!backlinksResult.ok) {
+    throw new Error(backlinksResult.error.message);
+  }
+  return {
+    backlinks: backlinksResult.value.length,
+    wikiLinks: linksResult.value.filter((entry) => entry.linkType === "wiki")
+      .length,
+    markdownLinks: linksResult.value.filter(
+      (entry) => entry.linkType === "markdown"
+    ).length,
+  };
+}
+
+function ensureEditable(doc: {
+  sourceExt: string;
+  sourceMime: string;
+  mirrorHash: string | null;
+}) {
+  const capabilities = getDocumentCapabilities({
+    sourceExt: doc.sourceExt,
+    sourceMime: doc.sourceMime,
+    contentAvailable: doc.mirrorHash !== null,
+  });
+  if (!capabilities.editable) {
+    throw new Error(
+      `${MCP_ERRORS.CONFLICT.code}: ${
+        capabilities.reason ?? "Document is read-only in place."
+      }`
+    );
+  }
+}
+
+export function handleCreateFolder(
+  args: CreateFolderInput,
+  ctx: ToolContext
+): Promise<ToolResult> {
+  return runTool(
+    ctx,
+    "gno_create_folder",
+    async () => {
+      if (!ctx.enableWrite) {
+        throw new Error("Write tools disabled. Start MCP with --enable-write.");
+      }
+
+      return withWriteLock(ctx.writeLockPath, async () => {
+        const collection = resolveCollection(ctx, args.collection);
+        const folderPath = planCreateFolder({
+          parentPath: args.parentPath,
+          name: args.name,
+        });
+        const fullPath = join(collection.path, folderPath);
+        await createFolderPath(fullPath);
+        return {
+          collection: collection.name,
+          folderPath,
+          path: fullPath,
+        };
+      });
+    },
+    (data) => `Created folder ${data.folderPath} in ${data.collection}`
+  );
+}
+
+export function handleRenameNote(
+  args: RenameNoteInput,
+  ctx: ToolContext
+): Promise<ToolResult> {
+  return runTool(
+    ctx,
+    "gno_rename_note",
+    async () => {
+      if (!ctx.enableWrite) {
+        throw new Error("Write tools disabled. Start MCP with --enable-write.");
+      }
+
+      return withWriteLock(ctx.writeLockPath, async () => {
+        const doc = await resolveDocByRef(ctx, args.ref);
+        ensureEditable(doc);
+        const collection = resolveCollection(ctx, doc.collection);
+        const plan = planRenameRefactor({
+          collection: collection.name,
+          currentRelPath: doc.relPath,
+          nextName: args.name,
+        });
+        const currentPath = join(collection.path, doc.relPath);
+        const nextPath = join(collection.path, plan.nextRelPath);
+        await renameFilePath(currentPath, nextPath);
+        await defaultSyncService.syncCollection(collection, ctx.store, {
+          runUpdateCmd: false,
+        });
+        return {
+          uri: plan.nextUri,
+          relPath: plan.nextRelPath,
+          warnings: buildRefactorWarnings(
+            await getRefactorSnapshot(ctx, doc.id),
+            { filenameChanged: true }
+          ).warnings,
+        };
+      });
+    },
+    (data) => `Renamed note to ${data.relPath}`
+  );
+}
+
+export function handleMoveNote(
+  args: MoveNoteInput,
+  ctx: ToolContext
+): Promise<ToolResult> {
+  return runTool(
+    ctx,
+    "gno_move_note",
+    async () => {
+      if (!ctx.enableWrite) {
+        throw new Error("Write tools disabled. Start MCP with --enable-write.");
+      }
+
+      return withWriteLock(ctx.writeLockPath, async () => {
+        const doc = await resolveDocByRef(ctx, args.ref);
+        ensureEditable(doc);
+        const collection = resolveCollection(ctx, doc.collection);
+        const plan = planMoveRefactor({
+          collection: collection.name,
+          currentRelPath: doc.relPath,
+          folderPath: args.folderPath,
+          nextName: args.name,
+        });
+        const currentPath = join(collection.path, doc.relPath);
+        const nextPath = join(collection.path, plan.nextRelPath);
+        await mkdir(dirname(nextPath), { recursive: true });
+        await renameFilePath(currentPath, nextPath);
+        await defaultSyncService.syncCollection(collection, ctx.store, {
+          runUpdateCmd: false,
+        });
+        return {
+          uri: plan.nextUri,
+          relPath: plan.nextRelPath,
+          warnings: buildRefactorWarnings(
+            await getRefactorSnapshot(ctx, doc.id),
+            {
+              folderChanged: true,
+              filenameChanged: Boolean(args.name),
+            }
+          ).warnings,
+        };
+      });
+    },
+    (data) => `Moved note to ${data.relPath}`
+  );
+}
+
+export function handleDuplicateNote(
+  args: DuplicateNoteInput,
+  ctx: ToolContext
+): Promise<ToolResult> {
+  return runTool(
+    ctx,
+    "gno_duplicate_note",
+    async () => {
+      if (!ctx.enableWrite) {
+        throw new Error("Write tools disabled. Start MCP with --enable-write.");
+      }
+
+      return withWriteLock(ctx.writeLockPath, async () => {
+        const doc = await resolveDocByRef(ctx, args.ref);
+        ensureEditable(doc);
+        const collection = resolveCollection(ctx, doc.collection);
+        const docsResult = await ctx.store.listDocuments(collection.name);
+        if (!docsResult.ok) {
+          throw new Error(docsResult.error.message);
+        }
+        const plan = planDuplicateRefactor({
+          collection: collection.name,
+          currentRelPath: doc.relPath,
+          folderPath: args.folderPath,
+          nextName: args.name,
+          existingRelPaths: docsResult.value.map((entry) => entry.relPath),
+        });
+        const currentPath = join(collection.path, doc.relPath);
+        const nextPath = join(collection.path, plan.nextRelPath);
+        await mkdir(dirname(nextPath), { recursive: true });
+        await copyFilePath(currentPath, nextPath);
+        await defaultSyncService.syncCollection(collection, ctx.store, {
+          runUpdateCmd: false,
+        });
+        return {
+          uri: plan.nextUri,
+          relPath: plan.nextRelPath,
+          warnings: buildRefactorWarnings(
+            await getRefactorSnapshot(ctx, doc.id)
+          ).warnings,
+        };
+      });
+    },
+    (data) => `Duplicated note to ${data.relPath}`
+  );
+}