Merge pull request #6 from kj455/feat/create-update-note

feat/create update note

Author: kj455

.changeset/hungry-olives-obey.md

@@ -0,0 +1,5 @@
+---
+'@kj455/mcp-kibela': minor
+---
+
+create and update note

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
 
 ---
 

package.json

@@ -25,7 +25,7 @@
     "build": "tsup src/index.ts --dts --format esm",
     "postbuild": "shx chmod +x dist/*.js",
     "check": "tsc --noEmit",
-    "build:watch": "npm run build --watch",
+    "build:watch": "npm run build -- --watch",
     "prepublishOnly": "npm run build",
     "format": "prettier --write .",
     "changeset": "changeset",

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/graphql/queries/updateNoteContent.ts

@@ -0,0 +1,36 @@
+import { TypedDocumentNode } from '@graphql-typed-document-node/core'
+import { gql } from 'graphql-tag'
+import { gqlRequest } from '../request'
+
+type UpdateNoteContentResponse = {
+  updateNoteContent: {
+    clientMutationId: string
+    note: {
+      id: string
+    }
+  }
+}
+
+type UpdateNoteContentVariables = {
+  input: {
+    clientMutationId: string
+    id: string
+    newContent: string
+    baseContent: string
+  }
+}
+
+const updateNoteContentMutation: TypedDocumentNode<UpdateNoteContentResponse, UpdateNoteContentVariables> = gql`
+  mutation UpdateNoteContent($input: UpdateNoteContentInput!) {
+    updateNoteContent(input: $input) {
+      clientMutationId
+      note {
+        id
+      }
+    }
+  }
+`
+
+export async function updateNoteContent(variables: UpdateNoteContentVariables): Promise<UpdateNoteContentResponse> {
+  return gqlRequest(updateNoteContentMutation, 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

@@ -3,12 +3,16 @@ import { getMyNotesTool } from './getMyNotes'
 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

@@ -0,0 +1,61 @@
+import { getNote } from '../graphql'
+import { updateNoteContent } from '../graphql/queries/updateNoteContent'
+import { uuid } from '../utils'
+import { ToolDefinition } from './types'
+
+export type UpdateNoteContentArgs = {
+  id: string
+  content: string
+}
+
+export const updateNoteContentTool: ToolDefinition<UpdateNoteContentArgs> = {
+  tool: {
+    name: 'kibela_update_note_content',
+    description:
+      'Update note content by note id. This tool allows you to modify the content of an existing Kibela note. Before updating, it fetches the current content of the note to ensure proper version control. Note that you need the note ID (not the note path) to use this tool.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        id: {
+          type: 'string',
+          description:
+            'Note id - not note path (e.g. /notes/123). If you want to update note content by note path, please use kibela_get_note_from_path tool first and get note id from the response',
+        },
+        content: {
+          type: 'string',
+          description:
+            'New content of the note in markdown format. The content will completely replace the existing note content. Make sure to include all necessary formatting, headers, and sections you want to preserve.',
+        },
+      },
+      required: ['id', 'content'],
+    },
+  },
+  handler: async ({ id, content }) => {
+    if (!id || !content) {
+      throw new Error('Note id and content are required')
+    }
+
+    const noteRes = await getNote({ id })
+    if (!noteRes.note) {
+      throw new Error('Note not found')
+    }
+
+    const response = await updateNoteContent({
+      input: {
+        clientMutationId: uuid(),
+        id,
+        newContent: content,
+        baseContent: noteRes.note.content,
+      },
+    })
+
+    return {
+      content: [
+        {
+          type: 'text',
+          text: JSON.stringify(response.updateNoteContent, null, 2),
+        },
+      ],
+    }
+  },
+}

src/utils.ts

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