Function handleReorderBlocks

packages/mcp/src/tools/writing.ts:773–885

(args: Record<string, unknown>)

}

async function handleReorderBlocks(args: Record<string, unknown>) {
  const parsedArgs = reorderBlocksArgsSchema.safeParse(args)
  if (!parsedArgs.success) {
    return writingError(`Invalid args in handleReorderBlocks: ${formatFirstIssue(parsedArgs.error)}`)
  }
  const filePath = parsedArgs.data.path
  const notebookFilter = parsedArgs.data.notebook
  const blockIds = parsedArgs.data.blockIds
  const dryRun = parsedArgs.data.dryRun === true

  const file = await loadDeepnoteFile(filePath)
  if (file.project.notebooks.length === 0) {
    return {
      content: [{ type: 'text', text: `No notebooks in project "${file.project.name}"` }],
      isError: true,
    }
  }

  // Find the target notebook
  let notebook = file.project.notebooks[0]
  if (notebookFilter) {
    const found = file.project.notebooks.find(n => n.name === notebookFilter || n.id === notebookFilter)
    if (!found) {
      return {
        content: [{ type: 'text', text: `Notebook not found: ${notebookFilter}` }],
        isError: true,
      }
    }
    notebook = found
  }

  // Resolve all block IDs (support prefix matching)
  const resolvedIds: string[] = []
  const resolvedIdSet = new Set<string>()
  for (const id of blockIds) {
    const fullId = resolveBlockId(notebook.blocks, id)
    if (!fullId) {
      return {
        content: [{ type: 'text', text: `Block not found: ${id}` }],
        isError: true,
      }
    }
    if (resolvedIdSet.has(fullId)) {
      return {
        content: [{ type: 'text', text: `Duplicate block ID in blockIds: ${id}` }],
        isError: true,
      }
    }
    resolvedIds.push(fullId)
    resolvedIdSet.add(fullId)
  }

  // Build a map of blocks by ID
  const blockMap = new Map(notebook.blocks.map(b => [b.id, b]))

  // Reorder blocks
  const reorderedBlocks = resolvedIds
    .map(id => blockMap.get(id))