@shareai-lab/kode 1.1.14 → 1.1.16-dev.2

package/src/test/testAdapters.ts

@@ -1,96 +0,0 @@
-import { ModelAdapterFactory } from '../services/modelAdapterFactory'
-import { getModelCapabilities } from '../constants/modelCapabilities'
-import { ModelProfile } from '../utils/config'
-
-// Test different models' adapter selection
-const testModels: ModelProfile[] = [
-  {
-    name: 'GPT-5 Test',
-    modelName: 'gpt-5',
-    provider: 'openai',
-    apiKey: 'test-key',
-    maxTokens: 8192,
-    contextLength: 128000,
-    reasoningEffort: 'medium',
-    isActive: true,
-    createdAt: Date.now()
-  },
-  {
-    name: 'GPT-4o Test',
-    modelName: 'gpt-4o',
-    provider: 'openai',
-    apiKey: 'test-key',
-    maxTokens: 4096,
-    contextLength: 128000,
-    isActive: true,
-    createdAt: Date.now()
-  },
-  {
-    name: 'Claude Test',
-    modelName: 'claude-3-5-sonnet-20241022',
-    provider: 'anthropic',
-    apiKey: 'test-key',
-    maxTokens: 4096,
-    contextLength: 200000,
-    isActive: true,
-    createdAt: Date.now()
-  },
-  {
-    name: 'O1 Test',
-    modelName: 'o1',
-    provider: 'openai',
-    apiKey: 'test-key',
-    maxTokens: 4096,
-    contextLength: 128000,
-    isActive: true,
-    createdAt: Date.now()
-  },
-  {
-    name: 'GLM-5 Test',
-    modelName: 'glm-5',
-    provider: 'custom',
-    apiKey: 'test-key',
-    maxTokens: 8192,
-    contextLength: 128000,
-    baseURL: 'https://api.glm.ai/v1',
-    isActive: true,
-    createdAt: Date.now()
-  }
-]
-
-console.log('🧪 Testing Model Adapter System\n')
-console.log('=' .repeat(60))
-
-testModels.forEach(model => {
-  console.log(`\n📊 Testing: ${model.name} (${model.modelName})`)
-  console.log('-'.repeat(40))
-  
-  // Get capabilities
-  const capabilities = getModelCapabilities(model.modelName)
-  console.log(`  ✓ API Architecture: ${capabilities.apiArchitecture.primary}`)
-  console.log(`  ✓ Fallback: ${capabilities.apiArchitecture.fallback || 'none'}`)
-  console.log(`  ✓ Max Tokens Field: ${capabilities.parameters.maxTokensField}`)
-  console.log(`  ✓ Tool Calling Mode: ${capabilities.toolCalling.mode}`)
-  console.log(`  ✓ Supports Freeform: ${capabilities.toolCalling.supportsFreeform}`)
-  console.log(`  ✓ Supports Streaming: ${capabilities.streaming.supported}`)
-  
-  // Test adapter creation
-  const adapter = ModelAdapterFactory.createAdapter(model)
-  console.log(`  ✓ Adapter Type: ${adapter.constructor.name}`)
-  
-  // Test shouldUseResponsesAPI
-  const shouldUseResponses = ModelAdapterFactory.shouldUseResponsesAPI(model)
-  console.log(`  ✓ Should Use Responses API: ${shouldUseResponses}`)
-  
-  // Test with custom endpoint
-  if (model.baseURL) {
-    const customModel = { ...model, baseURL: 'https://custom.api.com/v1' }
-    const customShouldUseResponses = ModelAdapterFactory.shouldUseResponsesAPI(customModel)
-    console.log(`  ✓ With Custom Endpoint: ${customShouldUseResponses ? 'Responses API' : 'Chat Completions'}`)
-  }
-})
-
-console.log('\n' + '='.repeat(60))
-console.log('✅ Adapter System Test Complete!')
-console.log('\nTo enable the new system, set USE_NEW_ADAPTERS=true')
-console.log('To use legacy system, set USE_NEW_ADAPTERS=false')

package/src/tools/ArchitectTool/ArchitectTool.tsx

@@ -1,135 +0,0 @@
-import type { TextBlock } from '@anthropic-ai/sdk/resources/index.mjs'
-import { Box } from 'ink'
-import * as React from 'react'
-import { z } from 'zod'
-import type { Tool } from '../../Tool'
-import { FallbackToolUseRejectedMessage } from '../../components/FallbackToolUseRejectedMessage'
-import { HighlightedCode } from '../../components/HighlightedCode'
-import { getContext } from '../../context'
-import { Message, query } from '../../query'
-import { lastX } from '../../utils/generators'
-import { createUserMessage } from '../../utils/messages'
-import { BashTool } from '../BashTool/BashTool'
-import { FileReadTool } from '../FileReadTool/FileReadTool'
-import { FileWriteTool } from '../FileWriteTool/FileWriteTool'
-import { GlobTool } from '../GlobTool/GlobTool'
-import { GrepTool } from '../GrepTool/GrepTool'
-import { LSTool } from '../lsTool/lsTool'
-import { ARCHITECT_SYSTEM_PROMPT, DESCRIPTION } from './prompt'
-
-const FS_EXPLORATION_TOOLS: Tool[] = [
-  BashTool,
-  LSTool,
-  FileReadTool,
-  FileWriteTool,
-  GlobTool,
-  GrepTool,
-]
-
-const inputSchema = z.strictObject({
-  prompt: z
-    .string()
-    .describe('The technical request or coding task to analyze'),
-  context: z
-    .string()
-    .describe('Optional context from previous conversation or system state')
-    .optional(),
-})
-
-export const ArchitectTool = {
-  name: 'Architect',
-  async description() {
-    return DESCRIPTION
-  },
-  inputSchema,
-  isReadOnly() {
-    return true
-  },
-  isConcurrencySafe() {
-    return true // ArchitectTool is read-only, safe for concurrent execution
-  },
-  userFacingName() {
-    return 'Architect'
-  },
-  async isEnabled() {
-    return false
-  },
-  needsPermissions() {
-    return false
-  },
-  async *call({ prompt, context }, toolUseContext) {
-    const content = context
-      ? `<context>${context}</context>\n\n${prompt}`
-      : prompt
-
-    const userMessage = createUserMessage(content)
-
-    const messages: Message[] = [userMessage]
-
-    // We only allow the file exploration tools to be used in the architect tool
-    const allowedTools = (toolUseContext.options?.tools ?? []).filter(_ =>
-      FS_EXPLORATION_TOOLS.map(_ => _.name).includes(_.name),
-    )
-
-    // Create a dummy canUseTool function since this tool controls its own tool usage
-    const canUseTool = async () => ({ result: true as const })
-
-    const lastResponse = await lastX(
-      query(
-        messages,
-        [ARCHITECT_SYSTEM_PROMPT],
-        await getContext(),
-        canUseTool,
-        {
-          ...toolUseContext,
-          setToolJSX: () => {}, // Dummy function since ArchitectTool doesn't use UI
-          options: { 
-            commands: toolUseContext.options?.commands || [],
-            forkNumber: toolUseContext.options?.forkNumber || 0,
-            messageLogName: toolUseContext.options?.messageLogName || 'default',
-            verbose: toolUseContext.options?.verbose || false,
-            safeMode: toolUseContext.options?.safeMode || false,
-            maxThinkingTokens: toolUseContext.options?.maxThinkingTokens || 0,
-            ...toolUseContext.options, 
-            tools: allowedTools 
-          },
-        },
-      ),
-    )
-
-    if (lastResponse.type !== 'assistant') {
-      throw new Error(`Invalid response from API`)
-    }
-
-    const data = lastResponse.message.content.filter(_ => _.type === 'text')
-    yield {
-      type: 'result',
-      data,
-      resultForAssistant: this.renderResultForAssistant(data),
-    }
-  },
-  async prompt() {
-    return DESCRIPTION
-  },
-  renderResultForAssistant(data: TextBlock[]): string {
-    return data.map(block => block.text).join('\n')
-  },
-  renderToolUseMessage(input) {
-    return Object.entries(input)
-      .map(([key, value]) => `${key}: ${JSON.stringify(value)}`)
-      .join(', ')
-  },
-  renderToolResultMessage(content) {
-    return (
-      <Box flexDirection="column" gap={1}>
-        <HighlightedCode
-          code={content.map(_ => _.text).join('\n')}
-          language="markdown"
-        />
-      </Box>
-    )
-  },
-  renderToolUseRejectedMessage() {
-    return <FallbackToolUseRejectedMessage />
-  },
-} satisfies Tool<typeof inputSchema, TextBlock[]>

package/src/tools/ArchitectTool/prompt.ts

@@ -1,15 +0,0 @@
-export const ARCHITECT_SYSTEM_PROMPT = `You are an expert software architect. Your role is to analyze technical requirements and produce clear, actionable implementation plans.
-These plans will then be carried out by a junior software engineer so you need to be specific and detailed. However do not actually write the code, just explain the plan.
-
-Follow these steps for each request:
-1. Carefully analyze requirements to identify core functionality and constraints
-2. Define clear technical approach with specific technologies and patterns
-3. Break down implementation into concrete, actionable steps at the appropriate level of abstraction
-
-Keep responses focused, specific and actionable. 
-
-IMPORTANT: Do not ask the user if you should implement the changes at the end. Just provide the plan as described above.
-IMPORTANT: Do not attempt to write the code or use any string modification tools. Just provide the plan.`
-
-export const DESCRIPTION =
-  'Your go-to tool for any technical or coding task. Analyzes requirements and breaks them down into clear, actionable implementation steps. Use this whenever you need help planning how to implement a feature, solve a technical problem, or structure your code.'