feat: create note

Author: kj455

README.md

@@ -10,10 +10,12 @@ A Model Context Protocol (MCP) server implementation that enables AI assistants
 
 The mcp-kibela server provides the following features:
 
-- 🔍 **Note Search**: Search Kibela notes by keywords
-- 📝 **My Notes**: Fetch your latest notes
-- 📖 **Note Content**: Get note content and comments by ID
-- 🔗 **Note by Path**: Get note content by path
+- **Note Search**: Search Kibela notes by keywords
+- **My Notes**: Fetch your latest notes
+- **Note Content**: Get note content and comments by ID
+- **Note by Path**: Get note content by path
+- **Create Note**: Create a new note
+- **Update Note Content**: Update note content by note id
 
 ---
 

src/graphql/queries/createNote.ts

@@ -0,0 +1,46 @@
+import { TypedDocumentNode } from '@graphql-typed-document-node/core'
+import { gql } from 'graphql-tag'
+import { gqlRequest } from '../request'
+
+type CreateNoteResponse = {
+  createNote: {
+    clientMutationId: string
+    note: {
+      id: string
+      title: string
+      content: string
+      url: string
+    }
+  }
+}
+
+type CreateNoteVariables = {
+  input: {
+    clientMutationId: string
+    title: string
+    content: string
+    coediting: boolean
+    groupIds: string[]
+    folders?: string[]
+    authorId?: string
+    draft?: boolean
+  }
+}
+
+const createNoteMutation: TypedDocumentNode<CreateNoteResponse, CreateNoteVariables> = gql`
+  mutation CreateNote($input: CreateNoteInput!) {
+    createNote(input: $input) {
+      clientMutationId
+      note {
+        id
+        title
+        content
+        url
+      }
+    }
+  }
+`
+
+export async function createNote(variables: CreateNoteVariables): Promise<CreateNoteResponse> {
+  return gqlRequest(createNoteMutation, variables)
+}

src/tools/createNote.ts

@@ -0,0 +1,88 @@
+import { createNote } from '../graphql/queries/createNote'
+import { uuid } from '../utils'
+import { ToolDefinition } from './types'
+
+export type CreateNoteArgs = {
+  title: string
+  content: string
+  groupIds: string[]
+  coediting: boolean
+  folders?: string[]
+  authorId?: string
+  draft?: boolean
+}
+
+export const createNoteTool: ToolDefinition<CreateNoteArgs> = {
+  tool: {
+    name: 'kibela_create_note',
+    description: 'Create a new note in Kibela.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        title: {
+          type: 'string',
+          description: 'required: Title of the note',
+        },
+        content: {
+          type: 'string',
+          description: 'required: Content of the note in markdown format',
+        },
+        groupIds: {
+          type: 'array',
+          items: {
+            type: 'string',
+          },
+          description: 'required: IDs of the groups to create the note in.',
+        },
+        folders: {
+          type: 'array',
+          items: {
+            type: 'string',
+          },
+          description: 'IDs of the folders to add the note to.',
+        },
+        authorId: {
+          type: 'string',
+          description:
+            'ID of the author of the note. If not specified, the note will be created by the authenticated user.',
+        },
+        coediting: {
+          type: 'boolean',
+          description: 'required: Whether to enable co-editing for the note',
+        },
+        draft: {
+          type: 'boolean',
+          description: 'Whether to create the note as a draft',
+        },
+      },
+      required: ['title', 'content'],
+    },
+  },
+  handler: async ({ title, content, groupIds, folders, authorId, coediting, draft }) => {
+    if (!title || !content || !groupIds || !coediting) {
+      throw new Error('Title, content, groupIds, and coediting are required')
+    }
+
+    const response = await createNote({
+      input: {
+        clientMutationId: uuid(),
+        title,
+        content,
+        groupIds,
+        folders,
+        authorId,
+        coediting,
+        draft,
+      },
+    })
+
+    return {
+      content: [
+        {
+          type: 'text',
+          text: JSON.stringify(response.createNote, null, 2),
+        },
+      ],
+    }
+  },
+}

src/tools/index.ts

@@ -4,13 +4,15 @@ import { getNoteContentTool } from './getNoteContent'
 import { getNoteFromPathTool } from './getNoteFromPath'
 import { ToolResponse } from './types'
 import { updateNoteContentTool } from './updateNoteContent'
+import { createNoteTool } from './createNote'
 
 const toolDefinitions = {
   kibela_search_notes: searchNotesTool,
   kibela_get_my_notes: getMyNotesTool,
   kibela_get_note_content: getNoteContentTool,
   kibela_get_note_from_path: getNoteFromPathTool,
   kibela_update_note_content: updateNoteContentTool,
+  kibela_create_note: createNoteTool,
 } as const
 
 export type ToolName = keyof typeof toolDefinitions

src/tools/updateNoteContent.ts

@@ -1,5 +1,6 @@
 import { getNote } from '../graphql'
 import { updateNoteContent } from '../graphql/queries/updateNoteContent'
+import { uuid } from '../utils'
 import { ToolDefinition } from './types'
 
 export type UpdateNoteContentArgs = {
@@ -41,7 +42,7 @@ export const updateNoteContentTool: ToolDefinition<UpdateNoteContentArgs> = {
 
     const response = await updateNoteContent({
       input: {
-        clientMutationId: 'updateNoteContent',
+        clientMutationId: uuid(),
         id,
         newContent: content,
         baseContent: noteRes.note.content,

src/utils.ts

@@ -0,0 +1,3 @@
+export const uuid = (): string => {
+  return crypto.randomUUID()
+}