@shareai-lab/kode 1.1.13 → 1.1.16

package/src/tools/NotebookEditTool/NotebookEditTool.tsx

@@ -1,298 +0,0 @@
-import { existsSync, readFileSync } from 'fs'
-import { Box, 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 { HighlightedCode } from '../../components/HighlightedCode'
-import type { Tool } from '../../Tool'
-import { NotebookCellType, NotebookContent } from '../../types/notebook'
-import {
-  detectFileEncoding,
-  detectLineEndings,
-  writeTextContent,
-} from '../../utils/file.js'
-import { safeParseJSON } from '../../utils/json'
-import { getCwd } from '../../utils/state'
-import { DESCRIPTION, PROMPT } from './prompt'
-import { hasWritePermission } from '../../utils/permissions/filesystem'
-import { emitReminderEvent } from '../../services/systemReminder'
-import { recordFileEdit } from '../../services/fileFreshness'
-
-const inputSchema = z.strictObject({
-  notebook_path: z
-    .string()
-    .describe(
-      'The absolute path to the Jupyter notebook file to edit (must be absolute, not relative)',
-    ),
-  cell_number: z.number().describe('The index of the cell to edit (0-based)'),
-  new_source: z.string().describe('The new source for the cell'),
-  cell_type: z
-    .enum(['code', 'markdown'])
-    .optional()
-    .describe(
-      'The type of the cell (code or markdown). If not specified, it defaults to the current cell type. If using edit_mode=insert, this is required.',
-    ),
-  edit_mode: z
-    .string()
-    .optional()
-    .describe(
-      'The type of edit to make (replace, insert, delete). Defaults to replace.',
-    ),
-})
-
-export const NotebookEditTool = {
-  name: 'NotebookEditCell',
-  async description() {
-    return DESCRIPTION
-  },
-  async prompt() {
-    return PROMPT
-  },
-  inputSchema,
-  userFacingName() {
-    return 'Edit Notebook'
-  },
-  async isEnabled() {
-    return true
-  },
-  isReadOnly() {
-    return false
-  },
-  isConcurrencySafe() {
-    return false // NotebookEditTool modifies state/files, not safe for concurrent execution
-  },
-  needsPermissions({ notebook_path }) {
-    return !hasWritePermission(notebook_path)
-  },
-  renderResultForAssistant({ cell_number, edit_mode, new_source, error }) {
-    if (error) {
-      return error
-    }
-    switch (edit_mode) {
-      case 'replace':
-        return `Updated cell ${cell_number} with ${new_source}`
-      case 'insert':
-        return `Inserted cell ${cell_number} with ${new_source}`
-      case 'delete':
-        return `Deleted cell ${cell_number}`
-    }
-  },
-  renderToolUseMessage(input, { verbose }) {
-    return `notebook_path: ${verbose ? input.notebook_path : relative(getCwd(), input.notebook_path)}, cell: ${input.cell_number}, content: ${input.new_source.slice(0, 30)}…, cell_type: ${input.cell_type}, edit_mode: ${input.edit_mode ?? 'replace'}`
-  },
-  renderToolUseRejectedMessage() {
-    return <FallbackToolUseRejectedMessage />
-  },
-  renderToolResultMessage({ cell_number, new_source, language, error }) {
-    if (error) {
-      return (
-        <Box flexDirection="column">
-          <Text color="red">{error}</Text>
-        </Box>
-      )
-    }
-
-    return (
-      <Box flexDirection="column">
-        <Text>Updated cell {cell_number}:</Text>
-        <Box marginLeft={2}>
-          <HighlightedCode code={new_source} language={language} />
-        </Box>
-      </Box>
-    )
-  },
-  async validateInput({
-    notebook_path,
-    cell_number,
-    cell_type,
-    edit_mode = 'replace',
-  }) {
-    const fullPath = isAbsolute(notebook_path)
-      ? notebook_path
-      : resolve(getCwd(), notebook_path)
-
-    if (!existsSync(fullPath)) {
-      return {
-        result: false,
-        message: 'Notebook file does not exist.',
-      }
-    }
-
-    if (extname(fullPath) !== '.ipynb') {
-      return {
-        result: false,
-        message:
-          'File must be a Jupyter notebook (.ipynb file). For editing other file types, use the FileEdit tool.',
-      }
-    }
-
-    if (cell_number < 0) {
-      return {
-        result: false,
-        message: 'Cell number must be non-negative.',
-      }
-    }
-
-    if (
-      edit_mode !== 'replace' &&
-      edit_mode !== 'insert' &&
-      edit_mode !== 'delete'
-    ) {
-      return {
-        result: false,
-        message: 'Edit mode must be replace, insert, or delete.',
-      }
-    }
-
-    if (edit_mode === 'insert' && !cell_type) {
-      return {
-        result: false,
-        message: 'Cell type is required when using edit_mode=insert.',
-      }
-    }
-
-    const enc = detectFileEncoding(fullPath)
-    const content = readFileSync(fullPath, enc)
-    const notebook = safeParseJSON(content) as NotebookContent | null
-    if (!notebook) {
-      return {
-        result: false,
-        message: 'Notebook is not valid JSON.',
-      }
-    }
-
-    if (edit_mode === 'insert' && cell_number > notebook.cells.length) {
-      return {
-        result: false,
-        message: `Cell number is out of bounds. For insert mode, the maximum value is ${notebook.cells.length} (to append at the end).`,
-      }
-    } else if (
-      (edit_mode === 'replace' || edit_mode === 'delete') &&
-      (cell_number >= notebook.cells.length || !notebook.cells[cell_number])
-    ) {
-      return {
-        result: false,
-        message: `Cell number is out of bounds. Notebook has ${notebook.cells.length} cells.`,
-      }
-    }
-
-    return { result: true }
-  },
-  async *call({
-    notebook_path,
-    cell_number,
-    new_source,
-    cell_type,
-    edit_mode,
-  }) {
-    const fullPath = isAbsolute(notebook_path)
-      ? notebook_path
-      : resolve(getCwd(), notebook_path)
-
-    try {
-      const enc = detectFileEncoding(fullPath)
-      const content = readFileSync(fullPath, enc)
-      const notebook = JSON.parse(content) as NotebookContent
-      const language = notebook.metadata.language_info?.name ?? 'python'
-
-      if (edit_mode === 'delete') {
-        // Delete the specified cell
-        notebook.cells.splice(cell_number, 1)
-      } else if (edit_mode === 'insert') {
-        // Insert the new cell
-        const new_cell = {
-          cell_type: cell_type!, // validateInput ensures cell_type is not undefined
-          source: new_source,
-          metadata: {},
-        }
-        notebook.cells.splice(
-          cell_number,
-          0,
-          cell_type == 'markdown' ? new_cell : { ...new_cell, outputs: [] },
-        )
-      } else {
-        // Find the specified cell
-        const targetCell = notebook.cells[cell_number]! // validateInput ensures cell_number is in bounds
-        targetCell.source = new_source
-        // Reset execution count and clear outputs since cell was modified
-        targetCell.execution_count = undefined
-        targetCell.outputs = []
-        if (cell_type && cell_type !== targetCell.cell_type) {
-          targetCell.cell_type = cell_type
-        }
-      }
-      // Write back to file
-      const endings = detectLineEndings(fullPath)
-      const updatedNotebook = JSON.stringify(notebook, null, 1)
-      writeTextContent(fullPath, updatedNotebook, enc, endings!)
-
-      // Record Agent edit operation for file freshness tracking
-      recordFileEdit(fullPath, updatedNotebook)
-
-      // Emit file edited event for system reminders
-      emitReminderEvent('file:edited', {
-        filePath: fullPath,
-        cellNumber: cell_number,
-        newSource: new_source,
-        cellType: cell_type,
-        editMode: edit_mode || 'replace',
-        timestamp: Date.now(),
-        operation: 'notebook_edit',
-      })
-      const data = {
-        cell_number,
-        new_source,
-        cell_type: cell_type ?? 'code',
-        language,
-        edit_mode: edit_mode ?? 'replace',
-        error: '',
-      }
-      yield {
-        type: 'result',
-        data,
-        resultForAssistant: this.renderResultForAssistant(data),
-      }
-    } catch (error) {
-      if (error instanceof Error) {
-        const data = {
-          cell_number,
-          new_source,
-          cell_type: cell_type ?? 'code',
-          language: 'python',
-          edit_mode: 'replace',
-          error: error.message,
-        }
-        yield {
-          type: 'result',
-          data,
-          resultForAssistant: this.renderResultForAssistant(data),
-        }
-        return
-      }
-      const data = {
-        cell_number,
-        new_source,
-        cell_type: cell_type ?? 'code',
-        language: 'python',
-        edit_mode: 'replace',
-        error: 'Unknown error occurred while editing notebook',
-      }
-      yield {
-        type: 'result',
-        data,
-        resultForAssistant: this.renderResultForAssistant(data),
-      }
-    }
-  },
-} satisfies Tool<
-  typeof inputSchema,
-  {
-    cell_number: number
-    new_source: string
-    cell_type: NotebookCellType
-    language: string
-    edit_mode: string
-    error?: string
-  }
->

package/src/tools/NotebookEditTool/prompt.ts

@@ -1,3 +0,0 @@
-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

@@ -1,258 +0,0 @@
-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'
-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[]
-
-
-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: this.renderResultForAssistant(cells),
-      data: cells,
-    }
-  },
-  renderResultForAssistant(data: NotebookCellSource[]) {
-    // Convert the complex structure to a string representation for the assistant
-    return data.map((cell, index) => {
-      let content = `Cell ${index + 1} (${cell.cellType}):\n${cell.source}`
-      if (cell.outputs && cell.outputs.length > 0) {
-        const outputText = cell.outputs.map(output => output.text).filter(Boolean).join('\n')
-        if (outputText) {
-          content += `\nOutput:\n${outputText}`
-        }
-      }
-      return content
-    }).join('\n\n')
-  },
-} 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'] as string | string[] | undefined),
-        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

@@ -1,3 +0,0 @@
-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

@@ -1,107 +0,0 @@
-import { z } from 'zod'
-import React from 'react'
-import { Text } from 'ink'
-import { Tool, ToolUseContext, ExtendedToolUseContext } from '../../Tool'
-import { DESCRIPTION, PROMPT } from './prompt'
-import {
-  StickerRequestForm,
-  FormData,
-} from '../../components/StickerRequestForm'
-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)
-    })
-
-    // Check if setToolJSX is available (cast context if needed)
-    const extendedContext = context as ExtendedToolUseContext
-    if (extendedContext.setToolJSX) {
-      extendedContext.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)
-            if (extendedContext.setToolJSX) {
-              extendedContext.setToolJSX(null) // Clear the JSX
-            }
-          }}
-          onClose={() => {
-            // Log form cancellation
-            logEvent('sticker_request_form_cancelled', {})
-            resolveForm(false)
-            if (extendedContext.setToolJSX) {
-              extendedContext.setToolJSX(null) // Clear the JSX
-            }
-          }}
-        />
-        ),
-        shouldHidePromptInput: true,
-      })
-    } else {
-      // Fallback if setToolJSX is not available
-      console.log('Sticker form would be displayed here, but setToolJSX is not available')
-      resolveForm(false)
-    }
-
-    // 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() {
-    return (
-      <Text>
-        &nbsp;&nbsp;⎿ &nbsp;
-        <Text color={getTheme().error}>No (Sticker request cancelled)</Text>
-      </Text>
-    )
-  },
-
-  renderResultForAssistant: (content: string) => content,
-}

package/src/tools/StickerRequestTool/prompt.ts

@@ -1,19 +0,0 @@
-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
-`