@shareai-lab/kode 1.0.70 → 1.0.71

package/src/commands/ctx_viz.ts

@@ -0,0 +1,209 @@
+import type { Command } from '../commands'
+import type { Tool } from '../Tool'
+import Table from 'cli-table3'
+import { getSystemPrompt } from '../constants/prompts'
+import { getContext } from '../context'
+import { zodToJsonSchema } from 'zod-to-json-schema'
+import { getMessagesGetter } from '../messages'
+import { PROJECT_FILE } from '../constants/product'
+// Quick and dirty estimate of bytes per token for rough token counts
+const BYTES_PER_TOKEN = 4
+
+interface Section {
+  title: string
+  content: string
+}
+
+interface ToolSummary {
+  name: string
+  description: string
+}
+
+function getContextSections(text: string): Section[] {
+  const sections: Section[] = []
+
+  // Find first <context> tag
+  const firstContextIndex = text.indexOf('<context')
+
+  // Everything before first tag is Core Sysprompt
+  if (firstContextIndex > 0) {
+    const coreSysprompt = text.slice(0, firstContextIndex).trim()
+    if (coreSysprompt) {
+      sections.push({
+        title: 'Core Sysprompt',
+        content: coreSysprompt,
+      })
+    }
+  }
+
+  let currentPos = firstContextIndex
+  let nonContextContent = ''
+
+  const regex = /<context\s+name="([^"]*)">([\s\S]*?)<\/context>/g
+  let match: RegExpExecArray | null
+
+  while ((match = regex.exec(text)) !== null) {
+    // Collect text between context tags
+    if (match.index > currentPos) {
+      nonContextContent += text.slice(currentPos, match.index)
+    }
+
+    const [, name = 'Unnamed Section', content = ''] = match
+    sections.push({
+      title: name === 'codeStyle' ? `CodeStyle + ${PROJECT_FILE}'s` : name,
+      content: content.trim(),
+    })
+
+    currentPos = match.index + match[0].length
+  }
+
+  // Collect remaining text after last tag
+  if (currentPos < text.length) {
+    nonContextContent += text.slice(currentPos)
+  }
+
+  // Add non-contextualized content if present
+  const trimmedNonContext = nonContextContent.trim()
+  if (trimmedNonContext) {
+    sections.push({
+      title: 'Non-contextualized Content',
+      content: trimmedNonContext,
+    })
+  }
+
+  return sections
+}
+
+function formatTokenCount(bytes: number): string {
+  const tokens = bytes / BYTES_PER_TOKEN
+  const k = tokens / 1000
+  return `${Math.round(k * 10) / 10}k`
+}
+
+function formatByteCount(bytes: number): string {
+  const kb = bytes / 1024
+  return `${Math.round(kb * 10) / 10}kb`
+}
+
+function createSummaryTable(
+  systemText: string,
+  systemSections: Section[],
+  tools: ToolSummary[],
+  messages: unknown,
+): string {
+  const table = new Table({
+    head: ['Component', 'Tokens', 'Size', '% Used'],
+    style: { head: ['bold'] },
+    chars: {
+      mid: '─',
+      'left-mid': '├',
+      'mid-mid': '┼',
+      'right-mid': '┤',
+    },
+  })
+
+  const messagesStr = JSON.stringify(messages)
+  const toolsStr = JSON.stringify(tools)
+
+  // Calculate total for percentages
+  const total = systemText.length + toolsStr.length + messagesStr.length
+  const getPercentage = (n: number) => `${Math.round((n / total) * 100)}%`
+
+  // System prompt and its sections
+  table.push([
+    'System prompt',
+    formatTokenCount(systemText.length),
+    formatByteCount(systemText.length),
+    getPercentage(systemText.length),
+  ])
+  for (const section of systemSections) {
+    table.push([
+      `  ${section.title}`,
+      formatTokenCount(section.content.length),
+      formatByteCount(section.content.length),
+      getPercentage(section.content.length),
+    ])
+  }
+
+  // Tools
+  table.push([
+    'Tool definitions',
+    formatTokenCount(toolsStr.length),
+    formatByteCount(toolsStr.length),
+    getPercentage(toolsStr.length),
+  ])
+  for (const tool of tools) {
+    table.push([
+      `  ${tool.name}`,
+      formatTokenCount(tool.description.length),
+      formatByteCount(tool.description.length),
+      getPercentage(tool.description.length),
+    ])
+  }
+
+  // Messages and total
+  table.push(
+    [
+      'Messages',
+      formatTokenCount(messagesStr.length),
+      formatByteCount(messagesStr.length),
+      getPercentage(messagesStr.length),
+    ],
+    ['Total', formatTokenCount(total), formatByteCount(total), '100%'],
+  )
+
+  return table.toString()
+}
+
+const command: Command = {
+  name: 'ctx-viz',
+  description:
+    'Show token usage breakdown for the current conversation context',
+  isEnabled: true,
+  isHidden: false,
+  type: 'local',
+
+  userFacingName() {
+    return this.name
+  },
+
+  async call(_args: string, cmdContext: { options: { tools: Tool[] } }) {
+    // Get tools and system prompt with injected context
+    const [systemPromptRaw, sysContext] = await Promise.all([
+      getSystemPrompt(),
+      getContext(),
+    ])
+
+    const rawTools = cmdContext.options.tools
+
+    // Full system prompt with context sections injected
+    let systemPrompt = systemPromptRaw.join('\n')
+    for (const [name, content] of Object.entries(sysContext)) {
+      systemPrompt += `\n<context name="${name}">${content}</context>`
+    }
+
+    // Get full tool definitions including prompts and schemas
+    const tools = rawTools.map(t => {
+      // Get full prompt and schema
+      const fullPrompt = t.prompt({ safeMode: false })
+      const schema = JSON.stringify(
+        'inputJSONSchema' in t && t.inputJSONSchema
+          ? t.inputJSONSchema
+          : zodToJsonSchema(t.inputSchema),
+      )
+
+      return {
+        name: t.name,
+        description: `${fullPrompt}\n\nSchema:\n${schema}`,
+      }
+    })
+
+    // Get current messages from REPL
+    const messages = getMessagesGetter()()
+
+    const sections = getContextSections(systemPrompt)
+    return createSummaryTable(systemPrompt, sections, tools, messages)
+  },
+}
+
+export default command

package/src/commands/doctor.ts

@@ -0,0 +1,24 @@
+import React from 'react'
+import type { Command } from '../commands'
+import { Doctor } from '../screens/Doctor'
+import { PRODUCT_NAME } from '../constants/product'
+
+const doctor: Command = {
+  name: 'doctor',
+  description: `Checks the health of your ${PRODUCT_NAME} installation`,
+  isEnabled: true,
+  isHidden: false,
+  userFacingName() {
+    return 'doctor'
+  },
+  type: 'local-jsx',
+  call(onDone) {
+    const element = React.createElement(Doctor, {
+      onDone,
+      doctorMode: true,
+    })
+    return Promise.resolve(element)
+  },
+}
+
+export default doctor

package/src/commands/help.tsx

@@ -0,0 +1,19 @@
+import { Command } from '../commands'
+import { Help } from '../components/Help'
+import * as React from 'react'
+
+const help = {
+  type: 'local-jsx',
+  name: 'help',
+  description: 'Show help and available commands',
+  isEnabled: true,
+  isHidden: false,
+  async call(onDone, { options: { commands } }) {
+    return <Help commands={commands} onClose={onDone} />
+  },
+  userFacingName() {
+    return 'help'
+  },
+} satisfies Command
+
+export default help

package/src/commands/init.ts

@@ -0,0 +1,37 @@
+import type { Command } from '../commands'
+import { markProjectOnboardingComplete } from '../ProjectOnboarding'
+import { PROJECT_FILE } from '../constants/product'
+const command = {
+  type: 'prompt',
+  name: 'init',
+  description: `Initialize a new ${PROJECT_FILE} file with codebase documentation`,
+  isEnabled: true,
+  isHidden: false,
+  progressMessage: 'analyzing your codebase',
+  userFacingName() {
+    return 'init'
+  },
+  async getPromptForCommand(_args: string) {
+    // Mark onboarding as complete when init command is run
+    markProjectOnboardingComplete()
+    return [
+      {
+        role: 'user',
+        content: [
+          {
+            type: 'text',
+            text: `Please analyze this codebase and create a ${PROJECT_FILE} file containing:
+1. Build/lint/test commands - especially for running a single test
+2. Code style guidelines including imports, formatting, types, naming conventions, error handling, etc.
+
+The file you create will be given to agentic coding agents (such as yourself) that operate in this repository. Make it about 20 lines long.
+If there's already a ${PROJECT_FILE}, improve it.
+If there are Cursor rules (in .cursor/rules/ or .cursorrules) or Copilot rules (in .github/copilot-instructions.md), make sure to include them.`,
+          },
+        ],
+      },
+    ]
+  },
+} satisfies Command
+
+export default command

package/src/commands/listen.ts

@@ -0,0 +1,42 @@
+import { Command } from '../commands'
+import { logError } from '../utils/log'
+import { execFileNoThrow } from '../utils/execFileNoThrow'
+
+const isEnabled =
+  process.platform === 'darwin' &&
+  ['iTerm.app', 'Apple_Terminal'].includes(process.env.TERM_PROGRAM || '')
+
+const listen: Command = {
+  type: 'local',
+  name: 'listen',
+  description: 'Activates speech recognition and transcribes speech to text',
+  isEnabled: isEnabled,
+  isHidden: isEnabled,
+  userFacingName() {
+    return 'listen'
+  },
+  async call(_, { abortController }) {
+    // Start dictation using AppleScript
+    const script = `tell application "System Events" to tell ¬
+(the first process whose frontmost is true) to tell ¬
+menu bar 1 to tell ¬
+menu bar item "Edit" to tell ¬
+menu "Edit" to tell ¬
+menu item "Start Dictation" to ¬
+if exists then click it`
+
+    const { stderr, code } = await execFileNoThrow(
+      'osascript',
+      ['-e', script],
+      abortController.signal,
+    )
+
+    if (code !== 0) {
+      logError(`Failed to start dictation: ${stderr}`)
+      return 'Failed to start dictation'
+    }
+    return 'Dictation started. Press esc to stop.'
+  },
+}
+
+export default listen

package/src/commands/login.tsx

@@ -0,0 +1,51 @@
+import * as React from 'react'
+import type { Command } from '../commands'
+import { ConsoleOAuthFlow } from '../components/ConsoleOAuthFlow'
+import { clearTerminal } from '../utils/terminal'
+import { isLoggedInToAnthropic } from '../utils/auth'
+import { useExitOnCtrlCD } from '../hooks/useExitOnCtrlCD'
+import { Box, Text } from 'ink'
+import { clearConversation } from './clear'
+
+export default () =>
+  ({
+    type: 'local-jsx',
+    name: 'login',
+    description: isLoggedInToAnthropic()
+      ? 'Switch Anthropic accounts'
+      : 'Sign in with your Anthropic account',
+    isEnabled: true,
+    isHidden: false,
+    async call(onDone, context) {
+      await clearTerminal()
+      return (
+        <Login
+          onDone={async () => {
+            clearConversation(context)
+            onDone()
+          }}
+        />
+      )
+    },
+    userFacingName() {
+      return 'login'
+    },
+  }) satisfies Command
+
+function Login(props: { onDone: () => void }) {
+  const exitState = useExitOnCtrlCD(props.onDone)
+  return (
+    <Box flexDirection="column">
+      <ConsoleOAuthFlow onDone={props.onDone} />
+      <Box marginLeft={3}>
+        <Text dimColor>
+          {exitState.pending ? (
+            <>Press {exitState.keyName} again to exit</>
+          ) : (
+            ''
+          )}
+        </Text>
+      </Box>
+    </Box>
+  )
+}

package/src/commands/logout.tsx

@@ -0,0 +1,40 @@
+import * as React from 'react'
+import type { Command } from '../commands'
+import { getGlobalConfig, saveGlobalConfig } from '../utils/config'
+import { clearTerminal } from '../utils/terminal'
+import { Text } from 'ink'
+
+export default {
+  type: 'local-jsx',
+  name: 'logout',
+  description: 'Sign out from your Anthropic account',
+  isEnabled: true,
+  isHidden: false,
+  async call() {
+    await clearTerminal()
+
+    const config = getGlobalConfig()
+
+    config.oauthAccount = undefined
+    config.hasCompletedOnboarding = false
+
+    if (config.customApiKeyResponses?.approved) {
+      config.customApiKeyResponses.approved = []
+    }
+
+    saveGlobalConfig(config)
+
+    const message = (
+      <Text>Successfully logged out from your Anthropic account.</Text>
+    )
+
+    setTimeout(() => {
+      process.exit(0)
+    }, 200)
+
+    return message
+  },
+  userFacingName() {
+    return 'logout'
+  },
+} satisfies Command

package/src/commands/mcp.ts

@@ -0,0 +1,41 @@
+import type { Command } from '../commands'
+import { listMCPServers, getClients } from '../services/mcpClient'
+import { PRODUCT_COMMAND } from '../constants/product'
+import chalk from 'chalk'
+import { getTheme } from '../utils/theme'
+
+const mcp = {
+  type: 'local',
+  name: 'mcp',
+  description: 'Show MCP server connection status',
+  isEnabled: true,
+  isHidden: false,
+  async call() {
+    const servers = listMCPServers()
+    const clients = await getClients()
+    const theme = getTheme()
+
+    if (Object.keys(servers).length === 0) {
+      return `⎿  No MCP servers configured. Run \`${PRODUCT_COMMAND} mcp\` to learn about how to configure MCP servers.`
+    }
+
+    // Sort servers by name and format status with colors
+    const serverStatusLines = clients
+      .sort((a, b) => a.name.localeCompare(b.name))
+      .map(client => {
+        const isConnected = client.type === 'connected'
+        const status = isConnected ? 'connected' : 'disconnected'
+        const coloredStatus = isConnected
+          ? chalk.hex(theme.success)(status)
+          : chalk.hex(theme.error)(status)
+        return `⎿  • ${client.name}: ${coloredStatus}`
+      })
+
+    return ['⎿  MCP Server Status', ...serverStatusLines].join('\n')
+  },
+  userFacingName() {
+    return 'mcp'
+  },
+} satisfies Command
+
+export default mcp

package/src/commands/model.tsx

@@ -0,0 +1,40 @@
+import React from 'react'
+import { render } from 'ink'
+import { ModelConfig } from '../components/ModelConfig'
+import { enableConfigs } from '../utils/config'
+import { triggerModelConfigChange } from '../messages'
+
+export const help = 'Change your AI provider and model settings'
+export const description = 'Change your AI provider and model settings'
+export const isEnabled = true
+export const isHidden = false
+export const name = 'model'
+export const type = 'local-jsx'
+
+export function userFacingName(): string {
+  return name
+}
+
+export async function call(
+  onDone: (result?: string) => void,
+  context: any,
+): Promise<React.ReactNode> {
+  const { abortController } = context
+  enableConfigs()
+  abortController?.abort?.()
+  return (
+    <ModelConfig
+      onClose={() => {
+        // Force ModelManager reload to ensure UI sync - wait for completion before closing
+        import('../utils/model').then(({ reloadModelManager }) => {
+          reloadModelManager()
+          // 🔧 Critical fix: Trigger global UI refresh after model config changes
+          // This ensures PromptInput component detects ModelManager singleton state changes
+          triggerModelConfigChange()
+          // Only close after reload is complete to ensure UI synchronization
+          onDone()
+        })
+      }}
+    />
+  )
+}

package/src/commands/modelstatus.tsx

@@ -0,0 +1,20 @@
+import React from 'react'
+import type { Command } from '../commands'
+import { ModelStatusDisplay } from '../components/ModelStatusDisplay'
+
+const modelstatus: Command = {
+  name: 'modelstatus',
+  description: 'Display current model configuration and status',
+  aliases: ['ms', 'model-status'],
+  isEnabled: true,
+  isHidden: false,
+  userFacingName() {
+    return 'modelstatus'
+  },
+  type: 'local-jsx',
+  call(onDone) {
+    return Promise.resolve(<ModelStatusDisplay onClose={onDone} />)
+  },
+}
+
+export default modelstatus

package/src/commands/onboarding.tsx

@@ -0,0 +1,34 @@
+import * as React from 'react'
+import type { Command } from '../commands'
+import { Onboarding } from '../components/Onboarding'
+import { clearTerminal } from '../utils/terminal'
+import { getGlobalConfig, saveGlobalConfig } from '../utils/config'
+import { clearConversation } from './clear'
+
+export default {
+  type: 'local-jsx',
+  name: 'onboarding',
+  description: 'Run through the onboarding flow',
+  isEnabled: true,
+  isHidden: false,
+  async call(onDone, context) {
+    await clearTerminal()
+    const config = getGlobalConfig()
+    saveGlobalConfig({
+      ...config,
+      theme: 'dark',
+    })
+
+    return (
+      <Onboarding
+        onDone={async () => {
+          clearConversation(context)
+          onDone()
+        }}
+      />
+    )
+  },
+  userFacingName() {
+    return 'onboarding'
+  },
+} satisfies Command

package/src/commands/pr_comments.ts

@@ -0,0 +1,59 @@
+import { Command } from '../commands'
+
+export default {
+  type: 'prompt',
+  name: 'pr-comments',
+  description: 'Get comments from a GitHub pull request',
+  progressMessage: 'fetching PR comments',
+  isEnabled: true,
+  isHidden: false,
+  userFacingName() {
+    return 'pr-comments'
+  },
+  async getPromptForCommand(args: string) {
+    return [
+      {
+        role: 'user',
+        content: [
+          {
+            type: 'text',
+            text: `You are an AI assistant integrated into a git-based version control system. Your task is to fetch and display comments from a GitHub pull request.
+
+Follow these steps:
+
+1. Use \`gh pr view --json number,headRepository\` to get the PR number and repository info
+2. Use \`gh api /repos/{owner}/{repo}/issues/{number}/comments\` to get PR-level comments
+3. Use \`gh api /repos/{owner}/{repo}/pulls/{number}/comments\` to get review comments. Pay particular attention to the following fields: \`body\`, \`diff_hunk\`, \`path\`, \`line\`, etc. If the comment references some code, consider fetching it using eg \`gh api /repos/{owner}/{repo}/contents/{path}?ref={branch} | jq .content -r | base64 -d\`
+4. Parse and format all comments in a readable way
+5. Return ONLY the formatted comments, with no additional text
+
+Format the comments as:
+
+## Comments
+
+[For each comment thread:]
+- @author file.ts#line:
+  \`\`\`diff
+  [diff_hunk from the API response]
+  \`\`\`
+  > quoted comment text
+  
+  [any replies indented]
+
+If there are no comments, return "No comments found."
+
+Remember:
+1. Only show the actual comments, no explanatory text
+2. Include both PR-level and code review comments
+3. Preserve the threading/nesting of comment replies
+4. Show the file and line number context for code review comments
+5. Use jq to parse the JSON responses from the GitHub API
+
+${args ? 'Additional user input: ' + args : ''}
+`,
+          },
+        ],
+      },
+    ]
+  },
+} satisfies Command

package/src/commands/refreshCommands.ts

@@ -0,0 +1,54 @@
+import { Command } from '../commands'
+import { reloadCustomCommands } from '../services/customCommands'
+import { getCommands } from '../commands'
+
+/**
+ * Refresh Commands - Reload custom commands from filesystem
+ *
+ * This command provides a runtime mechanism to refresh the custom commands
+ * cache without restarting the application. It's particularly useful during
+ * development or when users are actively creating/modifying custom commands.
+ *
+ * The command follows the standard local command pattern used throughout
+ * the project and provides detailed feedback about the refresh operation.
+ */
+const refreshCommands = {
+  type: 'local',
+  name: 'refresh-commands',
+  description: 'Reload custom commands from filesystem',
+  isEnabled: true,
+  isHidden: false,
+  async call(_, context) {
+    try {
+      // Clear custom commands cache to force filesystem rescan
+      reloadCustomCommands()
+
+      // Clear the main commands cache to ensure full reload
+      // This ensures that changes to custom commands are reflected in the main command list
+      getCommands.cache.clear?.()
+
+      // Reload commands to get updated count and validate the refresh
+      const commands = await getCommands()
+      const customCommands = commands.filter(
+        cmd => cmd.name.startsWith('project:') || cmd.name.startsWith('user:'),
+      )
+
+      // Provide detailed feedback about the refresh operation
+      return `✅ Commands refreshed successfully!
+
+Custom commands reloaded: ${customCommands.length}
+- Project commands: ${customCommands.filter(cmd => cmd.name.startsWith('project:')).length}
+- User commands: ${customCommands.filter(cmd => cmd.name.startsWith('user:')).length}
+
+Use /help to see updated command list.`
+    } catch (error) {
+      console.error('Failed to refresh commands:', error)
+      return '❌ Failed to refresh commands. Check console for details.'
+    }
+  },
+  userFacingName() {
+    return 'refresh-commands'
+  },
+} satisfies Command
+
+export default refreshCommands