Function handleRead

packages/mcp/src/tools/reading.ts:287–350

* Unified read handler that combines multiple reading operations

(args: Record<string, unknown>)

 * Unified read handler that combines multiple reading operations
 */
async function handleRead(args: Record<string, unknown>) {
  const parsedArgs = readArgsSchema.safeParse(args)
  if (!parsedArgs.success) {
    return {
      content: [
        {
          type: 'text',
          text: 'Invalid args for deepnote_read: path is required and optional fields must match expected types',
        },
      ],
      isError: true,
    }
  }
  const filePath = parsedArgs.data.path
  const includeRaw = parsedArgs.data.include
  const notebookFilter = parsedArgs.data.notebook
  const compact = parsedArgs.data.compact

  // Default to structure only
  const includeValues = includeRaw && includeRaw.length > 0 ? includeRaw : ['structure']
  const include = new Set(includeValues)
  const includeAll = include.has('all')

  let file: DeepnoteFile
  try {
    file = await loadDeepnoteFile(filePath)
  } catch (error) {
    const message = error instanceof Error ? error.message : String(error)
    return {
      content: [{ type: 'text', text: `Failed to read file "${filePath}": ${message}` }],
      isError: true,
    }
  }
  const result: Record<string, unknown> = { path: filePath }

  if (includeAll || include.has('structure')) {
    result.structure = computeStructure(file)
  }

  if (includeAll || include.has('stats')) {
    const stats = computeStats(file)
    result.stats = {
      totalLines: stats.totalLines,
      uniqueImports: stats.uniqueImports,
      importCount: stats.importCount,
    }
  }

  if (includeAll || include.has('lint')) {
    const issues = await computeLintIssues(file)
    result.lint = {
      issueCount: issues.length,
      issues: compact && issues.length === 0 ? undefined : issues,
    }
  }

  if (includeAll || include.has('dag')) {
    result.dag = await computeDagInfo(file, notebookFilter)