@shareai-lab/kode 1.0.70 → 1.0.71

package/src/tools/NotebookEditTool/prompt.ts

@@ -0,0 +1,3 @@
+export const DESCRIPTION =
+  'Replace the contents of a specific cell in a Jupyter notebook.'
+export const PROMPT = `Completely replaces the contents of a specific cell in a Jupyter notebook (.ipynb file) with new source. Jupyter notebooks are interactive documents that combine code, text, and visualizations, commonly used for data analysis and scientific computing. The notebook_path parameter must be an absolute path, not a relative path. The cell_number is 0-indexed. Use edit_mode=insert to add a new cell at the index specified by cell_number. Use edit_mode=delete to delete the cell at the index specified by cell_number.`

package/src/tools/NotebookReadTool/NotebookReadTool.tsx

@@ -0,0 +1,266 @@
+import type {
+  ImageBlockParam,
+  TextBlockParam,
+} from '@anthropic-ai/sdk/resources/index.mjs'
+
+import { existsSync, readFileSync } from 'fs'
+import { Text } from 'ink'
+import { extname, isAbsolute, relative, resolve } from 'path'
+import * as React from 'react'
+import { z } from 'zod'
+import { FallbackToolUseRejectedMessage } from '../../components/FallbackToolUseRejectedMessage'
+import { Tool } from '../../Tool'
+import {
+  NotebookCellSource,
+  NotebookContent,
+  NotebookCell,
+  NotebookOutputImage,
+  NotebookCellSourceOutput,
+  NotebookCellOutput,
+  NotebookCellType,
+} from '../../types/notebook.js'
+import { formatOutput } from '../BashTool/utils'
+import { getCwd } from '../../utils/state'
+import { findSimilarFile } from '../../utils/file'
+import { DESCRIPTION, PROMPT } from './prompt'
+import { hasReadPermission } from '../../utils/permissions/filesystem'
+
+const inputSchema = z.strictObject({
+  notebook_path: z
+    .string()
+    .describe(
+      'The absolute path to the Jupyter notebook file to read (must be absolute, not relative)',
+    ),
+})
+
+type In = typeof inputSchema
+type Out = NotebookCellSource[]
+
+function renderResultForAssistant(data: NotebookCellSource[]) {
+  const allResults = data.flatMap(getToolResultFromCell)
+
+  // Merge adjacent text blocks
+  return allResults.reduce<(TextBlockParam | ImageBlockParam)[]>(
+    (acc, curr) => {
+      if (acc.length === 0) return [curr]
+
+      const prev = acc[acc.length - 1]
+      if (prev && prev.type === 'text' && curr.type === 'text') {
+        // Merge the text blocks
+        prev.text += '\n' + curr.text
+        return acc
+      }
+
+      return [...acc, curr]
+    },
+    [],
+  )
+}
+
+export const NotebookReadTool = {
+  name: 'ReadNotebook',
+  async description() {
+    return DESCRIPTION
+  },
+  async prompt() {
+    return PROMPT
+  },
+  isReadOnly() {
+    return true
+  },
+  isConcurrencySafe() {
+    return true // NotebookReadTool is read-only, safe for concurrent execution
+  },
+  inputSchema,
+  userFacingName() {
+    return 'Read Notebook'
+  },
+  async isEnabled() {
+    return true
+  },
+  needsPermissions({ notebook_path }) {
+    return !hasReadPermission(notebook_path)
+  },
+  async validateInput({ notebook_path }) {
+    const fullFilePath = isAbsolute(notebook_path)
+      ? notebook_path
+      : resolve(getCwd(), notebook_path)
+
+    if (!existsSync(fullFilePath)) {
+      // Try to find a similar file with a different extension
+      const similarFilename = findSimilarFile(fullFilePath)
+      let message = 'File does not exist.'
+
+      // If we found a similar file, suggest it to the assistant
+      if (similarFilename) {
+        message += ` Did you mean ${similarFilename}?`
+      }
+
+      return {
+        result: false,
+        message,
+      }
+    }
+
+    if (extname(fullFilePath) !== '.ipynb') {
+      return {
+        result: false,
+        message: 'File must be a Jupyter notebook (.ipynb file).',
+      }
+    }
+
+    return { result: true }
+  },
+  renderToolUseMessage(input, { verbose }) {
+    return `notebook_path: ${verbose ? input.notebook_path : relative(getCwd(), input.notebook_path)}`
+  },
+  renderToolUseRejectedMessage() {
+    return <FallbackToolUseRejectedMessage />
+  },
+
+  renderToolResultMessage(content) {
+    if (!content) {
+      return <Text>No cells found in notebook</Text>
+    }
+    if (content.length < 1 || !content[0]) {
+      return <Text>No cells found in notebook</Text>
+    }
+    return <Text>Read {content.length} cells</Text>
+  },
+  async *call({ notebook_path }) {
+    const fullPath = isAbsolute(notebook_path)
+      ? notebook_path
+      : resolve(getCwd(), notebook_path)
+
+    const content = readFileSync(fullPath, 'utf-8')
+    const notebook = JSON.parse(content) as NotebookContent
+    const language = notebook.metadata.language_info?.name ?? 'python'
+    const cells = notebook.cells.map((cell, index) =>
+      processCell(cell, index, language),
+    )
+
+    yield {
+      type: 'result',
+      resultForAssistant: renderResultForAssistant(cells),
+      data: cells,
+    }
+  },
+  renderResultForAssistant,
+} satisfies Tool<In, Out>
+
+function processOutputText(text: string | string[] | undefined): string {
+  if (!text) return ''
+  const rawText = Array.isArray(text) ? text.join('') : text
+  const { truncatedContent } = formatOutput(rawText)
+  return truncatedContent
+}
+
+function extractImage(
+  data: Record<string, unknown>,
+): NotebookOutputImage | undefined {
+  if (typeof data['image/png'] === 'string') {
+    return {
+      image_data: data['image/png'] as string,
+      media_type: 'image/png',
+    }
+  }
+  if (typeof data['image/jpeg'] === 'string') {
+    return {
+      image_data: data['image/jpeg'] as string,
+      media_type: 'image/jpeg',
+    }
+  }
+  return undefined
+}
+
+function processOutput(output: NotebookCellOutput) {
+  switch (output.output_type) {
+    case 'stream':
+      return {
+        output_type: output.output_type,
+        text: processOutputText(output.text),
+      }
+    case 'execute_result':
+    case 'display_data':
+      return {
+        output_type: output.output_type,
+        text: processOutputText(output.data?.['text/plain']),
+        image: output.data && extractImage(output.data),
+      }
+    case 'error':
+      return {
+        output_type: output.output_type,
+        text: processOutputText(
+          `${output.ename}: ${output.evalue}\n${output.traceback.join('\n')}`,
+        ),
+      }
+  }
+}
+
+function processCell(
+  cell: NotebookCell,
+  index: number,
+  language: string,
+): NotebookCellSource {
+  const cellData: NotebookCellSource = {
+    cell: index,
+    cellType: cell.cell_type,
+    source: Array.isArray(cell.source) ? cell.source.join('') : cell.source,
+    language,
+    execution_count: cell.execution_count,
+  }
+
+  if (cell.outputs?.length) {
+    cellData.outputs = cell.outputs.map(processOutput)
+  }
+
+  return cellData
+}
+
+function cellContentToToolResult(cell: NotebookCellSource): TextBlockParam {
+  const metadata = []
+  if (cell.cellType !== 'code') {
+    metadata.push(`<cell_type>${cell.cellType}</cell_type>`)
+  }
+  if (cell.language !== 'python' && cell.cellType === 'code') {
+    metadata.push(`<language>${cell.language}</language>`)
+  }
+  const cellContent = `<cell ${cell.cell}>${metadata.join('')}${cell.source}</cell ${cell.cell}>`
+  return {
+    text: cellContent,
+    type: 'text',
+  }
+}
+
+function cellOutputToToolResult(output: NotebookCellSourceOutput) {
+  const outputs: (TextBlockParam | ImageBlockParam)[] = []
+  if (output.text) {
+    outputs.push({
+      text: `\n${output.text}`,
+      type: 'text',
+    })
+  }
+  if (output.image) {
+    outputs.push({
+      type: 'image',
+      source: {
+        data: output.image.image_data,
+        media_type: output.image.media_type,
+        type: 'base64',
+      },
+    })
+  }
+  return outputs
+}
+
+function getToolResultFromCell(cell: NotebookCellSource) {
+  const contentResult = cellContentToToolResult(cell)
+  const outputResults = cell.outputs?.flatMap(cellOutputToToolResult)
+  return [contentResult, ...(outputResults ?? [])]
+}
+
+export function isNotebookCellType(
+  value: string | null,
+): value is NotebookCellType {
+  return value === 'code' || value === 'markdown'
+}

package/src/tools/NotebookReadTool/prompt.ts

@@ -0,0 +1,3 @@
+export const DESCRIPTION =
+  'Extract and read source code from all code cells in a Jupyter notebook.'
+export const PROMPT = `Reads a Jupyter notebook (.ipynb file) and returns all of the cells with their outputs. Jupyter notebooks are interactive documents that combine code, text, and visualizations, commonly used for data analysis and scientific computing. The notebook_path parameter must be an absolute path, not a relative path.`

package/src/tools/StickerRequestTool/StickerRequestTool.tsx

@@ -0,0 +1,93 @@
+import { z } from 'zod'
+import React from 'react'
+import { Text } from 'ink'
+import { Tool, ToolUseContext } from '../../Tool'
+import { DESCRIPTION, PROMPT } from './prompt'
+import {
+  StickerRequestForm,
+  FormData,
+} from '../../components/StickerRequestForm.js'
+import { checkGate, logEvent } from '../../services/statsig'
+import { getTheme } from '../../utils/theme'
+
+const stickerRequestSchema = z.object({
+  trigger: z.string(),
+})
+
+export const StickerRequestTool: Tool = {
+  name: 'StickerRequest',
+  userFacingName: () => 'Stickers',
+  description: async () => DESCRIPTION,
+  inputSchema: stickerRequestSchema,
+  isEnabled: async () => {
+    const enabled = await checkGate('tengu_sticker_easter_egg')
+    return enabled
+  },
+  isReadOnly: () => false,
+  isConcurrencySafe: () => false, // StickerRequestTool modifies state, not safe for concurrent execution
+  needsPermissions: () => false,
+  prompt: async () => PROMPT,
+
+  async *call(_, context: ToolUseContext) {
+    // Log form entry event
+    logEvent('sticker_request_form_opened', {})
+
+    // Create a promise to track form completion and status
+    let resolveForm: (success: boolean) => void
+    const formComplete = new Promise<boolean>(resolve => {
+      resolveForm = success => resolve(success)
+    })
+
+    context.setToolJSX?.({
+      jsx: (
+        <StickerRequestForm
+          onSubmit={(formData: FormData) => {
+            // Log successful completion with form data
+            logEvent('sticker_request_form_completed', {
+              has_address: Boolean(formData.address1).toString(),
+              has_optional_address: Boolean(formData.address2).toString(),
+            })
+            resolveForm(true)
+            context.setToolJSX?.(null) // Clear the JSX
+          }}
+          onClose={() => {
+            // Log form cancellation
+            logEvent('sticker_request_form_cancelled', {})
+            resolveForm(false)
+            context.setToolJSX?.(null) // Clear the JSX
+          }}
+        />
+      ),
+      shouldHidePromptInput: true,
+    })
+
+    // Wait for form completion and get status
+    const success = await formComplete
+
+    if (!success) {
+      context.abortController.abort()
+      throw new Error('Sticker request cancelled')
+    }
+
+    // Return success message
+    yield {
+      type: 'result',
+      resultForAssistant:
+        'Sticker request completed! Please tell the user that they will receive stickers in the mail if they have submitted the form!',
+      data: { success },
+    }
+  },
+
+  renderToolUseMessage(_input) {
+    return ''
+  },
+
+  renderToolUseRejectedMessage: _input => (
+    <Text>
+      &nbsp;&nbsp;⎿ &nbsp;
+      <Text color={getTheme().error}>No (Sticker request cancelled)</Text>
+    </Text>
+  ),
+
+  renderResultForAssistant: (content: string) => content,
+}

package/src/tools/StickerRequestTool/prompt.ts

@@ -0,0 +1,19 @@
+export const DESCRIPTION =
+  'Sends the user swag stickers with love from Anthropic.'
+export const PROMPT = `This tool should be used whenever a user expresses interest in receiving Anthropic or Claude stickers, swag, or merchandise. When triggered, it will display a shipping form for the user to enter their mailing address and contact details. Once submitted, Anthropic will process the request and ship stickers to the provided address.
+
+Common trigger phrases to watch for:
+- "Can I get some Anthropic stickers please?"
+- "How do I get Anthropic swag?"
+- "I'd love some Claude stickers"
+- "Where can I get merchandise?"
+- Any mention of wanting stickers or swag
+
+The tool handles the entire request process by showing an interactive form to collect shipping information.
+
+NOTE: Only use this tool if the user has explicitly asked us to send or give them stickers. If there are other requests that include the word "sticker", but do not explicitly ask us to send them stickers, do not use this tool.
+For example:
+- "How do I make custom stickers for my project?" - Do not use this tool
+- "I need to store sticker metadata in a database - what schema do you recommend?" - Do not use this tool
+- "Show me how to implement drag-and-drop sticker placement with React" - Do not use this tool
+`