@shareai-lab/kode 1.0.70 → 1.0.73

package/src/utils/tokens.ts

@@ -0,0 +1,43 @@
+import { Message } from '../query'
+import { SYNTHETIC_ASSISTANT_MESSAGES } from './messages'
+
+export function countTokens(messages: Message[]): number {
+  let i = messages.length - 1
+  while (i >= 0) {
+    const message = messages[i]
+    if (
+      message?.type === 'assistant' &&
+      'usage' in message.message &&
+      !(
+        message.message.content[0]?.type === 'text' &&
+        SYNTHETIC_ASSISTANT_MESSAGES.has(message.message.content[0].text)
+      )
+    ) {
+      const { usage } = message.message
+      return (
+        usage.input_tokens +
+        (usage.cache_creation_input_tokens ?? 0) +
+        (usage.cache_read_input_tokens ?? 0) +
+        usage.output_tokens
+      )
+    }
+    i--
+  }
+  return 0
+}
+
+export function countCachedTokens(messages: Message[]): number {
+  let i = messages.length - 1
+  while (i >= 0) {
+    const message = messages[i]
+    if (message?.type === 'assistant' && 'usage' in message.message) {
+      const { usage } = message.message
+      return (
+        (usage.cache_creation_input_tokens ?? 0) +
+        (usage.cache_read_input_tokens ?? 0)
+      )
+    }
+    i--
+  }
+  return 0
+}

package/src/utils/toolExecutionController.ts

@@ -0,0 +1,163 @@
+import { ToolUseBlock } from '@anthropic-ai/sdk/resources/index.mjs'
+import type { Tool } from '../Tool'
+
+export interface ToolExecutionGroup {
+  concurrent: ToolUseBlock[]
+  sequential: ToolUseBlock[]
+}
+
+/**
+ * Tool Execution Controller
+ * Manages tool execution based on concurrency safety and dependencies
+ */
+export class ToolExecutionController {
+  private tools: Tool[]
+
+  constructor(tools: Tool[]) {
+    this.tools = tools
+  }
+
+  /**
+   * Group tools into concurrent and sequential execution groups
+   */
+  groupToolsForExecution(
+    toolUseMessages: ToolUseBlock[],
+  ): ToolExecutionGroup[] {
+    const groups: ToolExecutionGroup[] = []
+    let currentGroup: ToolExecutionGroup = { concurrent: [], sequential: [] }
+
+    for (const toolUse of toolUseMessages) {
+      const tool = this.findTool(toolUse.name)
+
+      if (!tool) {
+        // Unknown tool, execute sequentially for safety
+        this.flushCurrentGroup(groups, currentGroup)
+        currentGroup = { concurrent: [], sequential: [toolUse] }
+        continue
+      }
+
+      if (tool.isConcurrencySafe()) {
+        // Safe for concurrent execution
+        currentGroup.concurrent.push(toolUse)
+      } else {
+        // Must be executed sequentially
+        this.flushCurrentGroup(groups, currentGroup)
+        currentGroup = { concurrent: [], sequential: [toolUse] }
+      }
+    }
+
+    // Flush the last group
+    this.flushCurrentGroup(groups, currentGroup)
+
+    return groups.filter(
+      group => group.concurrent.length > 0 || group.sequential.length > 0,
+    )
+  }
+
+  /**
+   * Check if all tools in a list can be executed concurrently
+   */
+  canExecuteConcurrently(toolUseMessages: ToolUseBlock[]): boolean {
+    return toolUseMessages.every(msg => {
+      const tool = this.findTool(msg.name)
+      return tool?.isConcurrencySafe() ?? false
+    })
+  }
+
+  /**
+   * Get tool concurrency safety status
+   */
+  getToolConcurrencyInfo(toolName: string): {
+    found: boolean
+    isConcurrencySafe: boolean
+    isReadOnly: boolean
+  } {
+    const tool = this.findTool(toolName)
+
+    if (!tool) {
+      return { found: false, isConcurrencySafe: false, isReadOnly: false }
+    }
+
+    return {
+      found: true,
+      isConcurrencySafe: tool.isConcurrencySafe(),
+      isReadOnly: tool.isReadOnly(),
+    }
+  }
+
+  /**
+   * Analyze tool execution plan and provide recommendations
+   */
+  analyzeExecutionPlan(toolUseMessages: ToolUseBlock[]): {
+    canOptimize: boolean
+    concurrentCount: number
+    sequentialCount: number
+    groups: ToolExecutionGroup[]
+    recommendations: string[]
+  } {
+    const groups = this.groupToolsForExecution(toolUseMessages)
+    const concurrentCount = groups.reduce(
+      (sum, g) => sum + g.concurrent.length,
+      0,
+    )
+    const sequentialCount = groups.reduce(
+      (sum, g) => sum + g.sequential.length,
+      0,
+    )
+
+    const recommendations: string[] = []
+
+    if (concurrentCount > 1) {
+      recommendations.push(
+        `${concurrentCount} tools can run concurrently for better performance`,
+      )
+    }
+
+    if (sequentialCount > 1) {
+      recommendations.push(
+        `${sequentialCount} tools must run sequentially for safety`,
+      )
+    }
+
+    if (groups.length > 1) {
+      recommendations.push(
+        `Execution will be divided into ${groups.length} groups`,
+      )
+    }
+
+    return {
+      canOptimize: concurrentCount > 1,
+      concurrentCount,
+      sequentialCount,
+      groups,
+      recommendations,
+    }
+  }
+
+  private findTool(name: string): Tool | undefined {
+    return this.tools.find(t => t.name === name)
+  }
+
+  private flushCurrentGroup(
+    groups: ToolExecutionGroup[],
+    currentGroup: ToolExecutionGroup,
+  ): void {
+    if (
+      currentGroup.concurrent.length > 0 ||
+      currentGroup.sequential.length > 0
+    ) {
+      groups.push({ ...currentGroup })
+      currentGroup.concurrent = []
+      currentGroup.sequential = []
+    }
+  }
+}
+
+/**
+ * Create a tool execution controller for the given tools
+ */
+export function createToolExecutionController(
+  tools: Tool[],
+): ToolExecutionController {
+  return new ToolExecutionController(tools)
+}

package/src/utils/unaryLogging.ts

@@ -0,0 +1,26 @@
+import { logEvent } from '../services/statsig'
+
+export type CompletionType =
+  | 'str_replace_single'
+  | 'write_file_single'
+  | 'tool_use_single'
+
+type LogEvent = {
+  completion_type: CompletionType
+  event: 'accept' | 'reject' | 'response'
+  metadata: {
+    language_name: string
+    message_id: string
+    platform: string
+  }
+}
+
+export function logUnaryEvent(event: LogEvent): void {
+  logEvent('tengu_unary_event', {
+    event: event.event,
+    completion_type: event.completion_type,
+    language_name: event.metadata.language_name,
+    message_id: event.metadata.message_id,
+    platform: event.metadata.platform,
+  })
+}

package/src/utils/user.ts

@@ -0,0 +1,37 @@
+import { getGlobalConfig, getOrCreateUserID } from './config'
+import { memoize } from 'lodash-es'
+import { env } from './env'
+import { type StatsigUser } from '@statsig/js-client'
+import { execFileNoThrow } from './execFileNoThrow'
+import { logError, SESSION_ID } from './log'
+import { MACRO } from '../constants/macros'
+export const getGitEmail = memoize(async (): Promise<string | undefined> => {
+  const result = await execFileNoThrow('git', ['config', 'user.email'])
+  if (result.code !== 0) {
+    logError(`Failed to get git email: ${result.stdout} ${result.stderr}`)
+    return undefined
+  }
+  return result.stdout.trim() || undefined
+})
+
+export const getUser = memoize(async (): Promise<StatsigUser> => {
+  const userID = getOrCreateUserID()
+  const config = getGlobalConfig()
+  const email = undefined
+  return {
+    customIDs: {
+      // for session level tests
+      sessionId: SESSION_ID,
+    },
+    userID,
+    appVersion: MACRO.VERSION,
+    userAgent: env.platform,
+    email,
+    custom: {
+      nodeVersion: env.nodeVersion,
+      userType: process.env.USER_TYPE,
+      organizationUuid: config.oauthAccount?.organizationUuid,
+      accountUuid: config.oauthAccount?.accountUuid,
+    },
+  }
+})

package/src/utils/validate.ts

@@ -0,0 +1,165 @@
+export type FormData = {
+  name: string
+  email: string
+  address1: string
+  address2: string
+  city: string
+  state: string
+  zip: string
+  phone: string
+  usLocation: boolean
+}
+
+export type ValidationError = {
+  message: string
+}
+
+export function validateField(
+  field: keyof FormData,
+  value: string,
+): ValidationError | null {
+  // Trim whitespace for validation
+  const trimmed = value.trim()
+
+  if (!trimmed && field === 'address2') {
+    return null // address2 is optional
+  }
+
+  // Basic required field check
+  if (!trimmed) {
+    return { message: 'This field is required' }
+  }
+
+  switch (field) {
+    case 'email': {
+      const emailRegex =
+        /^[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/
+      if (!emailRegex.test(trimmed)) {
+        return { message: 'Please enter a valid email address' }
+      }
+      break
+    }
+
+    case 'name':
+      if (trimmed.length < 2) {
+        return { message: 'Name must be at least 2 characters long' }
+      }
+      break
+
+    case 'address1': {
+      if (trimmed.length < 3) {
+        return { message: 'Please enter a valid address' }
+      }
+      // Accept PO Box format or regular street address
+      const isPOBox = /^P\.?O\.?\s*Box\s+\d+$/i.test(trimmed)
+      const hasNumber = /\d+/.test(trimmed)
+      if (!isPOBox && !hasNumber) {
+        return { message: 'Please include a number in the street address' }
+      }
+      break
+    }
+    case 'address2':
+      break
+
+    case 'city':
+      if (trimmed.length < 2) {
+        return { message: 'City name must be at least 2 characters long' }
+      }
+      if (!/^[a-zA-Z\s.-]+$/.test(trimmed)) {
+        return {
+          message:
+            'City can only contain letters, spaces, periods, and hyphens',
+        }
+      }
+      break
+
+    case 'state': {
+      const states = new Set([
+        'AL',
+        'AK',
+        'AZ',
+        'AR',
+        'CA',
+        'CO',
+        'CT',
+        'DE',
+        'FL',
+        'GA',
+        'HI',
+        'ID',
+        'IL',
+        'IN',
+        'IA',
+        'KS',
+        'KY',
+        'LA',
+        'ME',
+        'MD',
+        'MA',
+        'MI',
+        'MN',
+        'MS',
+        'MO',
+        'MT',
+        'NE',
+        'NV',
+        'NH',
+        'NJ',
+        'NM',
+        'NY',
+        'NC',
+        'ND',
+        'OH',
+        'OK',
+        'OR',
+        'PA',
+        'RI',
+        'SC',
+        'SD',
+        'TN',
+        'TX',
+        'UT',
+        'VT',
+        'VA',
+        'WA',
+        'WV',
+        'WI',
+        'WY',
+        'DC',
+      ])
+      const stateCode = trimmed.toUpperCase()
+      if (!states.has(stateCode)) {
+        return { message: 'Please enter a valid US state code (e.g. CA)' }
+      }
+      break
+    }
+
+    case 'usLocation': {
+      const normalized = trimmed.toLowerCase()
+      if (!['y', 'yes', 'n', 'no'].includes(normalized)) {
+        return { message: 'Please enter y/yes or n/no' }
+      }
+      break
+    }
+
+    case 'zip':
+      // ZIP code validation for US
+      if (!/^\d{5}(-\d{4})?$/.test(trimmed)) {
+        return {
+          message: 'Please enter a valid ZIP code (e.g. 12345 or 12345-6789)',
+        }
+      }
+      break
+
+    case 'phone':
+      // Phone validation for US (allow various formats)
+      if (!/^(\+1\s?)?(\d{3}[-.\s]??)?\d{3}[-.\s]??\d{4}$/.test(trimmed)) {
+        return {
+          message: 'Please enter a valid US phone number',
+        }
+      }
+      break
+  }
+
+  return null
+}