@shareai-lab/kode 1.0.70 → 1.0.73

package/src/types/PermissionMode.ts

@@ -0,0 +1,120 @@
+// Permission mode types based on original Claude Code implementation
+export type PermissionMode =
+  | 'default'
+  | 'acceptEdits'
+  | 'plan'
+  | 'bypassPermissions'
+
+export interface PermissionContext {
+  mode: PermissionMode
+  allowedTools: string[]
+  allowedPaths: string[]
+  restrictions: {
+    readOnly: boolean
+    requireConfirmation: boolean
+    bypassValidation: boolean
+  }
+  metadata: {
+    activatedAt?: string
+    previousMode?: PermissionMode
+    transitionCount: number
+  }
+}
+
+export interface ModeConfig {
+  name: PermissionMode
+  label: string
+  icon: string
+  color: string
+  description: string
+  allowedTools: string[]
+  restrictions: {
+    readOnly: boolean
+    requireConfirmation: boolean
+    bypassValidation: boolean
+  }
+}
+
+// Mode configuration based on original Claude Code
+export const MODE_CONFIGS: Record<PermissionMode, ModeConfig> = {
+  default: {
+    name: 'default',
+    label: 'DEFAULT',
+    icon: '🔒',
+    color: 'blue',
+    description: 'Standard permission checking',
+    allowedTools: ['*'],
+    restrictions: {
+      readOnly: false,
+      requireConfirmation: true,
+      bypassValidation: false,
+    },
+  },
+  acceptEdits: {
+    name: 'acceptEdits',
+    label: 'ACCEPT EDITS',
+    icon: '✅',
+    color: 'green',
+    description: 'Auto-approve edit operations',
+    allowedTools: ['*'],
+    restrictions: {
+      readOnly: false,
+      requireConfirmation: false,
+      bypassValidation: false,
+    },
+  },
+  plan: {
+    name: 'plan',
+    label: 'PLAN MODE',
+    icon: '📝',
+    color: 'yellow',
+    description: 'Research and planning - read-only tools only',
+    allowedTools: [
+      'Read',
+      'Grep',
+      'Glob',
+      'LS',
+      'WebSearch',
+      'WebFetch',
+      'NotebookRead',
+      'exit_plan_mode',
+    ],
+    restrictions: {
+      readOnly: true,
+      requireConfirmation: true,
+      bypassValidation: false,
+    },
+  },
+  bypassPermissions: {
+    name: 'bypassPermissions',
+    label: 'BYPASS PERMISSIONS',
+    icon: '🔓',
+    color: 'red',
+    description: 'All permissions bypassed',
+    allowedTools: ['*'],
+    restrictions: {
+      readOnly: false,
+      requireConfirmation: false,
+      bypassValidation: true,
+    },
+  },
+}
+
+// Mode cycling function (based on original yg2 function)
+export function getNextPermissionMode(
+  currentMode: PermissionMode,
+  isBypassAvailable: boolean = true,
+): PermissionMode {
+  switch (currentMode) {
+    case 'default':
+      return 'acceptEdits'
+    case 'acceptEdits':
+      return 'plan'
+    case 'plan':
+      return isBypassAvailable ? 'bypassPermissions' : 'default'
+    case 'bypassPermissions':
+      return 'default'
+    default:
+      return 'default'
+  }
+}

package/src/types/RequestContext.ts

@@ -0,0 +1,72 @@
+// Request Context for perfect state isolation
+// Based on official Kode patterns
+
+export interface RequestContext {
+  id: string
+  abortController: AbortController
+  startTime: number
+  isActive: boolean
+  type: 'query' | 'tool' | 'koding'
+}
+
+export interface AbortBarrier {
+  requestId: string
+  checkAbort(): boolean
+  onAbort(callback: () => void): void
+  cleanup(): void
+}
+
+export function createRequestContext(
+  type: RequestContext['type'] = 'query',
+): RequestContext {
+  return {
+    id: crypto.randomUUID(),
+    abortController: new AbortController(),
+    startTime: Date.now(),
+    isActive: true,
+    type,
+  }
+}
+
+export function createAbortBarrier(
+  requestContext: RequestContext,
+): AbortBarrier {
+  let cleanupCallbacks: (() => void)[] = []
+
+  return {
+    requestId: requestContext.id,
+
+    checkAbort(): boolean {
+      // Only respond to aborts for THIS specific request
+      return (
+        requestContext.isActive && requestContext.abortController.signal.aborted
+      )
+    },
+
+    onAbort(callback: () => void): void {
+      if (requestContext.isActive) {
+        const abortHandler = () => {
+          if (requestContext.isActive) {
+            callback()
+          }
+        }
+        requestContext.abortController.signal.addEventListener(
+          'abort',
+          abortHandler,
+        )
+        cleanupCallbacks.push(() => {
+          requestContext.abortController.signal.removeEventListener(
+            'abort',
+            abortHandler,
+          )
+        })
+      }
+    },
+
+    cleanup(): void {
+      cleanupCallbacks.forEach(cleanup => cleanup())
+      cleanupCallbacks = []
+      requestContext.isActive = false
+    },
+  }
+}

package/src/types/conversation.ts

@@ -0,0 +1,51 @@
+// Type definitions for conversation and message functionality
+// Used by debugLogger and other conversation-related utilities
+
+import { UUID } from 'crypto'
+import type { MessageParam } from '@anthropic-ai/sdk/resources/index.mjs'
+import type { Message as APIAssistantMessage } from '@anthropic-ai/sdk/resources/index.mjs'
+
+/**
+ * Base message interface used throughout the conversation system
+ * This is a union type that matches the Message type from query.ts
+ */
+export type Message = UserMessage | AssistantMessage | ProgressMessage
+
+/**
+ * User message structure
+ */
+export interface UserMessage {
+  message: MessageParam
+  type: 'user'
+  uuid: UUID
+  toolUseResult?: any // FullToolUseResult type
+  options?: {
+    isKodingRequest?: boolean
+    kodingContext?: string
+  }
+}
+
+/**
+ * Assistant message structure
+ */
+export interface AssistantMessage {
+  costUSD: number
+  durationMs: number
+  message: APIAssistantMessage
+  type: 'assistant'
+  uuid: UUID
+  isApiErrorMessage?: boolean
+}
+
+/**
+ * Progress message structure for tool execution
+ */
+export interface ProgressMessage {
+  content: AssistantMessage
+  normalizedMessages: any[] // NormalizedMessage type
+  siblingToolUseIDs: Set<string>
+  tools: any[] // Tool type
+  toolUseID: string
+  type: 'progress'
+  uuid: UUID
+}

package/src/types/logs.ts

@@ -0,0 +1,58 @@
+// Type definitions for log-related functionality
+// Used by log selector, log list, and log utilities
+
+import { UUID } from 'crypto'
+
+/**
+ * Serialized message structure stored in log files
+ * Based on how messages are serialized and deserialized in log.ts
+ */
+export interface SerializedMessage {
+  type: 'user' | 'assistant' | 'progress'
+  uuid: UUID
+  message?: {
+    content: string | Array<{ type: string; text?: string }>
+    role: 'user' | 'assistant' | 'system'
+  }
+  costUSD?: number
+  durationMs?: number
+  timestamp: string
+  cwd?: string
+  userType?: string
+  sessionId?: string
+  version?: string
+}
+
+/**
+ * Log option representing a single conversation log
+ * Used by LogSelector and LogList components
+ */
+export interface LogOption {
+  // File metadata
+  date: string
+  fullPath: string
+  value: number // Index in the logs array
+  
+  // Timestamps for sorting
+  created: Date
+  modified: Date
+  
+  // Content metadata
+  firstPrompt: string
+  messageCount: number
+  messages: SerializedMessage[]
+  
+  // Fork and branch info
+  forkNumber?: number
+  sidechainNumber?: number
+}
+
+/**
+ * Props for LogList component
+ * Used by LogList.tsx
+ */
+export interface LogListProps {
+  context: {
+    unmount?: () => void
+  }
+}

package/src/types/modelCapabilities.ts

@@ -0,0 +1,64 @@
+// Model capability type definitions for unified API support
+export interface ModelCapabilities {
+  // API architecture type
+  apiArchitecture: {
+    primary: 'chat_completions' | 'responses_api'
+    fallback?: 'chat_completions'  // Responses API models can fallback
+  }
+  
+  // Parameter mapping
+  parameters: {
+    maxTokensField: 'max_tokens' | 'max_completion_tokens'
+    supportsReasoningEffort: boolean
+    supportsVerbosity: boolean
+    temperatureMode: 'flexible' | 'fixed_one' | 'restricted'
+  }
+  
+  // Tool calling capabilities
+  toolCalling: {
+    mode: 'none' | 'function_calling' | 'custom_tools'
+    supportsFreeform: boolean
+    supportsAllowedTools: boolean
+    supportsParallelCalls: boolean
+  }
+  
+  // State management
+  stateManagement: {
+    supportsResponseId: boolean
+    supportsConversationChaining: boolean
+    supportsPreviousResponseId: boolean
+  }
+  
+  // Streaming support
+  streaming: {
+    supported: boolean
+    includesUsage: boolean
+  }
+}
+
+// Unified request parameters
+export interface UnifiedRequestParams {
+  messages: any[]
+  systemPrompt: string[]
+  tools?: any[]
+  maxTokens: number
+  stream?: boolean
+  previousResponseId?: string
+  reasoningEffort?: 'minimal' | 'low' | 'medium' | 'high'
+  verbosity?: 'low' | 'medium' | 'high'
+  temperature?: number
+  allowedTools?: string[]
+}
+
+// Unified response format
+export interface UnifiedResponse {
+  id: string
+  content: string
+  toolCalls?: any[]
+  usage: {
+    promptTokens: number
+    completionTokens: number
+    reasoningTokens?: number
+  }
+  responseId?: string  // For Responses API state management
+}

package/src/types/notebook.ts

@@ -0,0 +1,87 @@
+// Type definitions for Jupyter notebook functionality
+// Used by NotebookReadTool and NotebookEditTool
+
+/**
+ * Valid notebook cell types
+ */
+export type NotebookCellType = 'code' | 'markdown'
+
+/**
+ * Notebook output image structure
+ */
+export interface NotebookOutputImage {
+  image_data: string
+  media_type: 'image/png' | 'image/jpeg'
+}
+
+/**
+ * Processed notebook cell output for display
+ */
+export interface NotebookCellSourceOutput {
+  output_type: 'stream' | 'execute_result' | 'display_data' | 'error'
+  text?: string
+  image?: NotebookOutputImage
+}
+
+/**
+ * Processed notebook cell structure used by tools
+ */
+export interface NotebookCellSource {
+  cell: number // Cell index
+  cellType: NotebookCellType
+  source: string
+  language: string
+  execution_count?: number | null
+  outputs?: NotebookCellSourceOutput[]
+}
+
+/**
+ * Raw notebook cell output from .ipynb file
+ */
+export interface NotebookCellOutput {
+  output_type: 'stream' | 'execute_result' | 'display_data' | 'error'
+  name?: string
+  text?: string | string[]
+  data?: Record<string, unknown>
+  execution_count?: number | null
+  metadata?: Record<string, unknown>
+  // For error outputs
+  ename?: string
+  evalue?: string
+  traceback?: string[]
+}
+
+/**
+ * Raw notebook cell structure from .ipynb file
+ */
+export interface NotebookCell {
+  cell_type: NotebookCellType
+  source: string | string[]
+  metadata: Record<string, unknown>
+  execution_count?: number | null
+  outputs?: NotebookCellOutput[]
+  id?: string
+}
+
+/**
+ * Complete notebook structure from .ipynb file
+ */
+export interface NotebookContent {
+  cells: NotebookCell[]
+  metadata: {
+    kernelspec?: {
+      display_name?: string
+      language?: string
+      name?: string
+    }
+    language_info?: {
+      name?: string
+      version?: string
+      mimetype?: string
+      file_extension?: string
+    }
+    [key: string]: unknown
+  }
+  nbformat: number
+  nbformat_minor: number
+}