@shareai-lab/kode 1.1.13 → 1.1.16-dev.1

package/src/components/binary-feedback/utils.ts

@@ -1,220 +0,0 @@
-import { TextBlock, ToolUseBlock } from '@anthropic-ai/sdk/resources/index.mjs'
-import { AssistantMessage, BinaryFeedbackResult } from '../../query'
-import { MAIN_QUERY_TEMPERATURE } from '../../services/claude'
-import { getDynamicConfig, logEvent } from '../../services/statsig'
-
-import { isEqual, zip } from 'lodash-es'
-import { getGitState } from '../../utils/git'
-
-export type BinaryFeedbackChoice =
-  | 'prefer-left'
-  | 'prefer-right'
-  | 'neither'
-  | 'no-preference'
-
-export type BinaryFeedbackChoose = (choice: BinaryFeedbackChoice) => void
-
-type BinaryFeedbackConfig = {
-  sampleFrequency: number
-}
-
-async function getBinaryFeedbackStatsigConfig(): Promise<BinaryFeedbackConfig> {
-  return await getDynamicConfig('tengu-binary-feedback-config', {
-    sampleFrequency: 0,
-  })
-}
-
-function getMessageBlockSequence(m: AssistantMessage) {
-  return m.message.content.map(cb => {
-    if (cb.type === 'text') return 'text'
-    if (cb.type === 'tool_use') return cb.name
-    return cb.type // Handle other block types like 'thinking' or 'redacted_thinking'
-  })
-}
-
-export async function logBinaryFeedbackEvent(
-  m1: AssistantMessage,
-  m2: AssistantMessage,
-  choice: BinaryFeedbackChoice,
-): Promise<void> {
-  const modelA = m1.message.model
-  const modelB = m2.message.model
-  const gitState = await getGitState()
-  logEvent('tengu_binary_feedback', {
-    msg_id_A: m1.message.id,
-    msg_id_B: m2.message.id,
-    choice: {
-      'prefer-left': m1.message.id,
-      'prefer-right': m2.message.id,
-      neither: undefined,
-      'no-preference': undefined,
-    }[choice],
-    choiceStr: choice,
-    gitHead: gitState?.commitHash,
-    gitBranch: gitState?.branchName,
-    gitRepoRemoteUrl: gitState?.remoteUrl || undefined,
-    gitRepoIsHeadOnRemote: gitState?.isHeadOnRemote?.toString(),
-    gitRepoIsClean: gitState?.isClean?.toString(),
-    modelA,
-    modelB,
-    temperatureA: String(MAIN_QUERY_TEMPERATURE),
-    temperatureB: String(MAIN_QUERY_TEMPERATURE),
-    seqA: String(getMessageBlockSequence(m1)),
-    seqB: String(getMessageBlockSequence(m2)),
-  })
-}
-
-export async function logBinaryFeedbackSamplingDecision(
-  decision: boolean,
-  reason?: string,
-): Promise<void> {
-  logEvent('tengu_binary_feedback_sampling_decision', {
-    decision: decision.toString(),
-    reason,
-  })
-}
-
-export async function logBinaryFeedbackDisplayDecision(
-  decision: boolean,
-  m1: AssistantMessage,
-  m2: AssistantMessage,
-  reason?: string,
-): Promise<void> {
-  logEvent('tengu_binary_feedback_display_decision', {
-    decision: decision.toString(),
-    reason,
-    msg_id_A: m1.message.id,
-    msg_id_B: m2.message.id,
-    seqA: String(getMessageBlockSequence(m1)),
-    seqB: String(getMessageBlockSequence(m2)),
-  })
-}
-
-function textContentBlocksEqual(cb1: TextBlock, cb2: TextBlock): boolean {
-  return cb1.text === cb2.text
-}
-
-function contentBlocksEqual(
-  cb1: TextBlock | ToolUseBlock,
-  cb2: TextBlock | ToolUseBlock,
-): boolean {
-  if (cb1.type !== cb2.type) {
-    return false
-  }
-  if (cb1.type === 'text') {
-    return textContentBlocksEqual(cb1, cb2 as TextBlock)
-  }
-  cb2 = cb2 as ToolUseBlock
-  return cb1.name === cb2.name && isEqual(cb1.input, cb2.input)
-}
-
-function allContentBlocksEqual(
-  content1: (TextBlock | ToolUseBlock)[],
-  content2: (TextBlock | ToolUseBlock)[],
-): boolean {
-  if (content1.length !== content2.length) {
-    return false
-  }
-  return zip(content1, content2).every(([cb1, cb2]) =>
-    contentBlocksEqual(cb1!, cb2!),
-  )
-}
-
-export async function shouldUseBinaryFeedback(): Promise<boolean> {
-  if (process.env.DISABLE_BINARY_FEEDBACK) {
-    logBinaryFeedbackSamplingDecision(false, 'disabled_by_env_var')
-    return false
-  }
-  if (process.env.FORCE_BINARY_FEEDBACK) {
-    logBinaryFeedbackSamplingDecision(true, 'forced_by_env_var')
-    return true
-  }
-  if (process.env.USER_TYPE !== 'ant') {
-    logBinaryFeedbackSamplingDecision(false, 'not_ant')
-    return false
-  }
-  if (process.env.NODE_ENV === 'test') {
-    // Binary feedback breaks a couple tests related to checking for permission,
-    // so we have to disable it in tests at the risk of hiding bugs
-    logBinaryFeedbackSamplingDecision(false, 'test')
-    return false
-  }
-
-  const config = await getBinaryFeedbackStatsigConfig()
-  if (config.sampleFrequency === 0) {
-    logBinaryFeedbackSamplingDecision(false, 'top_level_frequency_zero')
-    return false
-  }
-  if (Math.random() > config.sampleFrequency) {
-    logBinaryFeedbackSamplingDecision(false, 'top_level_frequency_rng')
-    return false
-  }
-  logBinaryFeedbackSamplingDecision(true)
-  return true
-}
-
-export function messagePairValidForBinaryFeedback(
-  m1: AssistantMessage,
-  m2: AssistantMessage,
-): boolean {
-  const logPass = () => logBinaryFeedbackDisplayDecision(true, m1, m2)
-  const logFail = (reason: string) =>
-    logBinaryFeedbackDisplayDecision(false, m1, m2, reason)
-
-  // Ignore thinking blocks, on the assumption that users don't find them very relevant
-  // compared to other content types
-  const nonThinkingBlocks1 = m1.message.content.filter(
-    b => b.type !== 'thinking' && b.type !== 'redacted_thinking',
-  )
-  const nonThinkingBlocks2 = m2.message.content.filter(
-    b => b.type !== 'thinking' && b.type !== 'redacted_thinking',
-  )
-  const hasToolUse =
-    nonThinkingBlocks1.some(b => b.type === 'tool_use') ||
-    nonThinkingBlocks2.some(b => b.type === 'tool_use')
-
-  // If they're all text blocks, compare those
-  if (!hasToolUse) {
-    if (allContentBlocksEqual(nonThinkingBlocks1, nonThinkingBlocks2)) {
-      logFail('contents_identical')
-      return false
-    }
-    logPass()
-    return true
-  }
-
-  // If there are tools, they're the most material difference between the messages.
-  // Only show binary feedback if there's a tool use difference, ignoring text.
-  if (
-    allContentBlocksEqual(
-      nonThinkingBlocks1.filter(b => b.type === 'tool_use'),
-      nonThinkingBlocks2.filter(b => b.type === 'tool_use'),
-    )
-  ) {
-    logFail('contents_identical')
-    return false
-  }
-
-  logPass()
-  return true
-}
-
-export function getBinaryFeedbackResultForChoice(
-  m1: AssistantMessage,
-  m2: AssistantMessage,
-  choice: BinaryFeedbackChoice,
-): BinaryFeedbackResult {
-  switch (choice) {
-    case 'prefer-left':
-      return { message: m1, shouldSkipPermissionCheck: true }
-    case 'prefer-right':
-      return { message: m2, shouldSkipPermissionCheck: true }
-    case 'no-preference':
-      return {
-        message: Math.random() < 0.5 ? m1 : m2,
-        shouldSkipPermissionCheck: false,
-      }
-    case 'neither':
-      return { message: null, shouldSkipPermissionCheck: false }
-  }
-}

package/src/components/messages/AssistantBashOutputMessage.tsx

@@ -1,22 +0,0 @@
-import * as React from 'react'
-import BashToolResultMessage from '../../tools/BashTool/BashToolResultMessage'
-import { extractTag } from '../../utils/messages'
-
-export function AssistantBashOutputMessage({
-  content,
-  verbose,
-}: {
-  content: string
-  verbose?: boolean
-}): React.ReactNode {
-  const stdout = extractTag(content, 'bash-stdout') ?? ''
-  const stderr = extractTag(content, 'bash-stderr') ?? ''
-  const stdoutLines = stdout.split('\n').length
-  const stderrLines = stderr.split('\n').length
-  return (
-    <BashToolResultMessage
-      content={{ stdout, stdoutLines, stderr, stderrLines }}
-      verbose={!!verbose}
-    />
-  )
-}

package/src/components/messages/AssistantLocalCommandOutputMessage.tsx

@@ -1,49 +0,0 @@
-import * as React from 'react'
-import { extractTag } from '../../utils/messages'
-import { getTheme } from '../../utils/theme'
-import { Box, Text } from 'ink'
-
-export function AssistantLocalCommandOutputMessage({
-  content,
-}: {
-  content: string
-}): React.ReactNode[] {
-  const stdout = extractTag(content, 'local-command-stdout')
-  const stderr = extractTag(content, 'local-command-stderr')
-  if (!stdout && !stderr) {
-    return []
-  }
-  const theme = getTheme()
-  let insides = [
-    format(stdout?.trim(), theme.text),
-    format(stderr?.trim(), theme.error),
-  ].filter(Boolean)
-
-  if (insides.length === 0) {
-    insides = [
-      <React.Fragment key="0">
-        <Text>(No output)</Text>
-      </React.Fragment>
-    ]
-  }
-
-  return [
-    <Box key="0" gap={1}>
-      <Box>
-        <Text color={theme.secondaryText}>{'  '}⎿ </Text>
-      </Box>
-      {insides.map((_, index) => (
-        <Box key={index} flexDirection="column">
-          {_}
-        </Box>
-      ))}
-    </Box>,
-  ]
-}
-
-function format(content: string | undefined, color: string): React.ReactNode {
-  if (!content) {
-    return null
-  }
-  return <Text color={color}>{content}</Text>
-}

package/src/components/messages/AssistantRedactedThinkingMessage.tsx

@@ -1,19 +0,0 @@
-import React from 'react'
-import { Box, Text } from 'ink'
-import { getTheme } from '../../utils/theme'
-
-type Props = {
-  addMargin: boolean
-}
-
-export function AssistantRedactedThinkingMessage({
-  addMargin = false,
-}: Props): React.ReactNode {
-  return (
-    <Box marginTop={addMargin ? 1 : 0}>
-      <Text color={getTheme().secondaryText} italic>
-        ✻ Thinking…
-      </Text>
-    </Box>
-  )
-}

package/src/components/messages/AssistantTextMessage.tsx

@@ -1,144 +0,0 @@
-import { TextBlockParam } from '@anthropic-ai/sdk/resources/index.mjs'
-import React from 'react'
-import { AssistantBashOutputMessage } from './AssistantBashOutputMessage'
-import { AssistantLocalCommandOutputMessage } from './AssistantLocalCommandOutputMessage'
-import { getTheme } from '../../utils/theme'
-import { Box, Text } from 'ink'
-import { Cost } from '../Cost'
-import {
-  API_ERROR_MESSAGE_PREFIX,
-  CREDIT_BALANCE_TOO_LOW_ERROR_MESSAGE,
-  INVALID_API_KEY_ERROR_MESSAGE,
-  PROMPT_TOO_LONG_ERROR_MESSAGE,
-} from '../../services/claude.js'
-import {
-  CANCEL_MESSAGE,
-  INTERRUPT_MESSAGE,
-  INTERRUPT_MESSAGE_FOR_TOOL_USE,
-  isEmptyMessageText,
-  NO_RESPONSE_REQUESTED,
-} from '../../utils/messages.js'
-import { BLACK_CIRCLE } from '../../constants/figures'
-import { applyMarkdown } from '../../utils/markdown'
-import { useTerminalSize } from '../../hooks/useTerminalSize'
-
-type Props = {
-  param: TextBlockParam
-  costUSD: number
-  durationMs: number
-  debug: boolean
-  addMargin: boolean
-  shouldShowDot: boolean
-  verbose?: boolean
-  width?: number | string
-}
-
-export function AssistantTextMessage({
-  param: { text },
-  costUSD,
-  durationMs,
-  debug,
-  addMargin,
-  shouldShowDot,
-  verbose,
-}: Props): React.ReactNode {
-  const { columns } = useTerminalSize()
-  if (isEmptyMessageText(text)) {
-    return null
-  }
-
-  // Show bash output
-  if (text.startsWith('<bash-stdout') || text.startsWith('<bash-stderr')) {
-    return <AssistantBashOutputMessage content={text} verbose={verbose} />
-  }
-
-  // Show command output
-  if (
-    text.startsWith('<local-command-stdout') ||
-    text.startsWith('<local-command-stderr')
-  ) {
-    return <AssistantLocalCommandOutputMessage content={text} />
-  }
-
-  if (text.startsWith(API_ERROR_MESSAGE_PREFIX)) {
-    return (
-      <Text>
-        &nbsp;&nbsp;⎿ &nbsp;
-        <Text color={getTheme().error}>
-          {text === API_ERROR_MESSAGE_PREFIX
-            ? `${API_ERROR_MESSAGE_PREFIX}: Please wait a moment and try again.`
-            : text}
-        </Text>
-      </Text>
-    )
-  }
-
-  switch (text) {
-    // Local JSX commands don't need a response, but we still want Claude to see them
-    // Tool results render their own interrupt messages
-    case NO_RESPONSE_REQUESTED:
-    case INTERRUPT_MESSAGE_FOR_TOOL_USE:
-      return null
-
-    case INTERRUPT_MESSAGE:
-    case CANCEL_MESSAGE:
-      return (
-        <Text>
-          &nbsp;&nbsp;⎿ &nbsp;
-          <Text color={getTheme().error}>Interrupted by user</Text>
-        </Text>
-      )
-
-    case PROMPT_TOO_LONG_ERROR_MESSAGE:
-      return (
-        <Text>
-          &nbsp;&nbsp;⎿ &nbsp;
-          <Text color={getTheme().error}>
-            Context low &middot; Run /compact to compact & continue
-          </Text>
-        </Text>
-      )
-
-    case CREDIT_BALANCE_TOO_LOW_ERROR_MESSAGE:
-      return (
-        <Text>
-          &nbsp;&nbsp;⎿ &nbsp;
-          <Text color={getTheme().error}>
-            Credit balance too low &middot; Add funds:
-            https://console.anthropic.com/settings/billing
-          </Text>
-        </Text>
-      )
-
-    case INVALID_API_KEY_ERROR_MESSAGE:
-      return (
-        <Text>
-          &nbsp;&nbsp;⎿ &nbsp;
-          <Text color={getTheme().error}>{INVALID_API_KEY_ERROR_MESSAGE}</Text>
-        </Text>
-      )
-
-    default:
-      return (
-        <Box
-          alignItems="flex-start"
-          flexDirection="row"
-          justifyContent="space-between"
-          marginTop={addMargin ? 1 : 0}
-          width="100%"
-        >
-          <Box flexDirection="row">
-            {shouldShowDot && (
-              <Box minWidth={2}>
-                <Text color={getTheme().text}>{BLACK_CIRCLE}</Text>
-              </Box>
-            )}
-            <Box flexDirection="column" width={columns - 6}>
-              <Text>{applyMarkdown(text)}</Text>
-            </Box>
-          </Box>
-          <Cost costUSD={costUSD} durationMs={durationMs} debug={debug} />
-        </Box>
-      )
-  }
-}

package/src/components/messages/AssistantThinkingMessage.tsx

@@ -1,40 +0,0 @@
-import React from 'react'
-import { Box, Text } from 'ink'
-import { getTheme } from '../../utils/theme'
-import { applyMarkdown } from '../../utils/markdown'
-import {
-  ThinkingBlock,
-  ThinkingBlockParam,
-} from '@anthropic-ai/sdk/resources/index.mjs'
-
-type Props = {
-  param: ThinkingBlock | ThinkingBlockParam
-  addMargin: boolean
-}
-
-export function AssistantThinkingMessage({
-  param: { thinking },
-  addMargin = false,
-}: Props): React.ReactNode {
-  if (!thinking) {
-    return null
-  }
-
-  return (
-    <Box
-      flexDirection="column"
-      gap={1}
-      marginTop={addMargin ? 1 : 0}
-      width="100%"
-    >
-      <Text color={getTheme().secondaryText} italic>
-        ✻ Thinking…
-      </Text>
-      <Box paddingLeft={2}>
-        <Text color={getTheme().secondaryText} italic>
-          {applyMarkdown(thinking)}
-        </Text>
-      </Box>
-    </Box>
-  )
-}

package/src/components/messages/AssistantToolUseMessage.tsx

@@ -1,132 +0,0 @@
-import { Box, Text } from 'ink'
-import React from 'react'
-import { logError } from '../../utils/log'
-import { ToolUseBlockParam } from '@anthropic-ai/sdk/resources/index.mjs'
-import { Tool } from '../../Tool'
-import { Cost } from '../Cost'
-import { ToolUseLoader } from '../ToolUseLoader'
-import { getTheme } from '../../utils/theme'
-import { BLACK_CIRCLE } from '../../constants/figures'
-import { ThinkTool } from '../../tools/ThinkTool/ThinkTool'
-import { AssistantThinkingMessage } from './AssistantThinkingMessage'
-import { TaskToolMessage } from './TaskToolMessage'
-
-type Props = {
-  param: ToolUseBlockParam
-  costUSD: number
-  durationMs: number
-  addMargin: boolean
-  tools: Tool[]
-  debug: boolean
-  verbose: boolean
-  erroredToolUseIDs: Set<string>
-  inProgressToolUseIDs: Set<string>
-  unresolvedToolUseIDs: Set<string>
-  shouldAnimate: boolean
-  shouldShowDot: boolean
-}
-
-export function AssistantToolUseMessage({
-  param,
-  costUSD,
-  durationMs,
-  addMargin,
-  tools,
-  debug,
-  verbose,
-  erroredToolUseIDs,
-  inProgressToolUseIDs,
-  unresolvedToolUseIDs,
-  shouldAnimate,
-  shouldShowDot,
-}: Props): React.ReactNode {
-  const tool = tools.find(_ => _.name === param.name)
-  if (!tool) {
-    logError(`Tool ${param.name} not found`)
-    return null
-  }
-  const isQueued =
-    !inProgressToolUseIDs.has(param.id) && unresolvedToolUseIDs.has(param.id)
-  // Keeping color undefined makes the OS use the default color regardless of appearance
-  const color = isQueued ? getTheme().secondaryText : undefined
-
-  // TODO: Avoid this special case
-  if (tool === ThinkTool) {
-    // params were already validated in query(), so this won't throe
-    const { thought } = ThinkTool.inputSchema.parse(param.input)
-    return (
-      <AssistantThinkingMessage
-        param={{ thinking: thought, signature: '', type: 'thinking' }}
-        addMargin={addMargin}
-      />
-    )
-  }
-
-  const userFacingToolName = tool.userFacingName ? tool.userFacingName() : tool.name
-  return (
-    <Box
-      flexDirection="row"
-      justifyContent="space-between"
-      marginTop={addMargin ? 1 : 0}
-      width="100%"
-    >
-      <Box>
-        <Box
-          flexWrap="nowrap"
-          minWidth={userFacingToolName.length + (shouldShowDot ? 2 : 0)}
-        >
-          {shouldShowDot &&
-            (isQueued ? (
-              <Box minWidth={2}>
-                <Text color={color}>{BLACK_CIRCLE}</Text>
-              </Box>
-            ) : (
-              <ToolUseLoader
-                shouldAnimate={shouldAnimate}
-                isUnresolved={unresolvedToolUseIDs.has(param.id)}
-                isError={erroredToolUseIDs.has(param.id)}
-              />
-            ))}
-          {tool.name === 'Task' && param.input ? (
-            <TaskToolMessage
-              agentType={String((param.input as any).subagent_type || 'general-purpose')}
-              bold={Boolean(!isQueued)}
-              children={String(userFacingToolName || '')}
-            />
-          ) : (
-            <Text color={color} bold={!isQueued}>
-              {userFacingToolName}
-            </Text>
-          )}
-        </Box>
-        <Box flexWrap="nowrap">
-          {Object.keys(param.input as { [key: string]: unknown }).length > 0 &&
-            (() => {
-              const toolMessage = tool.renderToolUseMessage(
-                param.input as never,
-                {
-                  verbose,
-                },
-              )
-
-              // If the tool returns a React component, render it directly
-              if (React.isValidElement(toolMessage)) {
-                return (
-                  <Box flexDirection="row">
-                    <Text color={color}>(</Text>
-                    {toolMessage}
-                    <Text color={color}>)</Text>
-                  </Box>
-                )
-              }
-
-              // If it's a string, wrap it in Text
-              return <Text color={color}>({toolMessage})</Text>
-            })()}
-          <Text color={color}>…</Text>
-        </Box>
-      </Box>
-      <Cost costUSD={costUSD} durationMs={durationMs} debug={debug} />
-    </Box>
-  )
-}

package/src/components/messages/TaskProgressMessage.tsx

@@ -1,32 +0,0 @@
-import React from 'react'
-import { Box, Text } from 'ink'
-import { getTheme } from '../../utils/theme'
-
-interface Props {
-  agentType: string
-  status: string
-  toolCount?: number
-}
-
-export function TaskProgressMessage({ agentType, status, toolCount }: Props) {
-  const theme = getTheme()
-  
-  return (
-    <Box flexDirection="column" marginTop={1}>
-      <Box flexDirection="row">
-        <Text color={theme.kode}>⎯ </Text>
-        <Text color={theme.text} bold>
-          [{agentType}]
-        </Text>
-        <Text color={theme.secondaryText}> {status}</Text>
-      </Box>
-      {toolCount && toolCount > 0 && (
-        <Box marginLeft={3}>
-          <Text color={theme.secondaryText}>
-            Tools used: {toolCount}
-          </Text>
-        </Box>
-      )}
-    </Box>
-  )
-}