@shareai-lab/kode 1.0.70 → 1.0.71

package/src/commands/release-notes.ts

@@ -0,0 +1,34 @@
+import { MACRO } from '../constants/macros.js'
+import type { Command } from '../commands'
+import { RELEASE_NOTES } from '../constants/releaseNotes'
+
+const releaseNotes: Command = {
+  description: 'Show release notes for the current or specified version',
+  isEnabled: false,
+  isHidden: false,
+  name: 'release-notes',
+  userFacingName() {
+    return 'release-notes'
+  },
+  type: 'local',
+  async call(args) {
+    const currentVersion = MACRO.VERSION
+
+    // If a specific version is requested, show that version's notes
+    const requestedVersion = args ? args.trim() : currentVersion
+
+    // Get the requested version's notes
+    const notes = RELEASE_NOTES[requestedVersion]
+
+    if (!notes || notes.length === 0) {
+      return `No release notes available for version ${requestedVersion}.`
+    }
+
+    const header = `Release notes for version ${requestedVersion}:`
+    const formattedNotes = notes.map(note => `• ${note}`).join('\n')
+
+    return `${header}\n\n${formattedNotes}`
+  },
+}
+
+export default releaseNotes

package/src/commands/resume.tsx

@@ -0,0 +1,30 @@
+import * as React from 'react'
+import type { Command } from '../commands'
+import { ResumeConversation } from '../screens/ResumeConversation'
+import { render } from 'ink'
+import { CACHE_PATHS, loadLogList } from '../utils/log'
+
+export default {
+  type: 'local-jsx',
+  name: 'resume',
+  description: 'Resume a previous conversation',
+  isEnabled: true,
+  isHidden: false,
+  userFacingName() {
+    return 'resume'
+  },
+  async call(onDone, { options: { commands, tools, verbose } }) {
+    const logs = await loadLogList(CACHE_PATHS.messages())
+    render(
+      <ResumeConversation
+        commands={commands}
+        context={{ unmount: onDone }}
+        logs={logs}
+        tools={tools}
+        verbose={verbose}
+      />,
+    )
+    // This return is here for type only
+    return null
+  },
+} satisfies Command

package/src/commands/review.ts

@@ -0,0 +1,49 @@
+import { Command } from '../commands'
+import { BashTool } from '../tools/BashTool/BashTool'
+
+export default {
+  type: 'prompt',
+  name: 'review',
+  description: 'Review a pull request',
+  isEnabled: true,
+  isHidden: false,
+  progressMessage: 'reviewing pull request',
+  userFacingName() {
+    return 'review'
+  },
+  async getPromptForCommand(args) {
+    return [
+      {
+        role: 'user',
+        content: [
+          {
+            type: 'text',
+            text: `
+      You are an expert code reviewer. Follow these steps:
+
+      1. If no PR number is provided in the args, use ${BashTool.name}("gh pr list") to show open PRs
+      2. If a PR number is provided, use ${BashTool.name}("gh pr view <number>") to get PR details
+      3. Use ${BashTool.name}("gh pr diff <number>") to get the diff
+      4. Analyze the changes and provide a thorough code review that includes:
+         - Overview of what the PR does
+         - Analysis of code quality and style
+         - Specific suggestions for improvements
+         - Any potential issues or risks
+      
+      Keep your review concise but thorough. Focus on:
+      - Code correctness
+      - Following project conventions
+      - Performance implications
+      - Test coverage
+      - Security considerations
+
+      Format your review with clear sections and bullet points.
+
+      PR number: ${args}
+    `,
+          },
+        ],
+      },
+    ]
+  },
+} satisfies Command

package/src/commands/terminalSetup.ts

@@ -0,0 +1,221 @@
+import { Command } from '../commands'
+import { EOL, platform, homedir } from 'os'
+import { execFileNoThrow } from '../utils/execFileNoThrow'
+import chalk from 'chalk'
+import { getTheme } from '../utils/theme'
+import { env } from '../utils/env'
+import { getGlobalConfig, saveGlobalConfig } from '../utils/config'
+import { markProjectOnboardingComplete } from '../ProjectOnboarding'
+import { readFileSync, writeFileSync } from 'fs'
+import { join } from 'path'
+import { safeParseJSON } from '../utils/json'
+import { logError } from '../utils/log'
+
+const terminalSetup: Command = {
+  type: 'local',
+  name: 'terminal-setup',
+  userFacingName() {
+    return 'terminal-setup'
+  },
+  description:
+    'Install Shift+Enter key binding for newlines (iTerm2 and VSCode only)',
+  isEnabled:
+    (platform() === 'darwin' && env.terminal === 'iTerm.app') ||
+    env.terminal === 'vscode',
+  isHidden: false,
+  async call() {
+    let result = ''
+
+    switch (env.terminal) {
+      case 'iTerm.app':
+        result = await installBindingsForITerm2()
+        break
+      case 'vscode':
+        result = installBindingsForVSCodeTerminal()
+        break
+    }
+
+    // Update global config to indicate Shift+Enter key binding is installed
+    const config = getGlobalConfig()
+    config.shiftEnterKeyBindingInstalled = true
+    saveGlobalConfig(config)
+
+    // Mark onboarding as complete
+    markProjectOnboardingComplete()
+
+    return result
+  },
+}
+
+export function isShiftEnterKeyBindingInstalled(): boolean {
+  return getGlobalConfig().shiftEnterKeyBindingInstalled === true
+}
+
+export function handleHashCommand(interpreted: string): void {
+  // Appends the AI-interpreted content to both KODE.md and CLAUDE.md (if exists)
+  try {
+    const cwd = process.cwd()
+    const codeContextPath = join(cwd, 'KODE.md')
+    const claudePath = join(cwd, 'CLAUDE.md')
+
+    // Check which files exist and update them
+    const filesToUpdate = []
+
+    // Always try to update KODE.md (create if not exists)
+    filesToUpdate.push({ path: codeContextPath, name: 'KODE.md' })
+
+    // Update CLAUDE.md only if it exists
+    try {
+      readFileSync(claudePath, 'utf-8')
+      filesToUpdate.push({ path: claudePath, name: 'CLAUDE.md' })
+    } catch {
+      // CLAUDE.md doesn't exist, skip it
+    }
+
+    const now = new Date()
+    const timezoneMatch = now.toString().match(/\(([A-Z]+)\)/)
+    const timezone = timezoneMatch
+      ? timezoneMatch[1]
+      : now
+          .toLocaleTimeString('en-us', { timeZoneName: 'short' })
+          .split(' ')
+          .pop()
+
+    const timestamp = interpreted.includes(now.getFullYear().toString())
+      ? ''
+      : `\n\n_Added on ${now.toLocaleString()} ${timezone}_`
+
+    const updatedFiles = []
+
+    for (const file of filesToUpdate) {
+      try {
+        // Check if file exists, if not create it
+        let existingContent = ''
+        try {
+          existingContent = readFileSync(file.path, 'utf-8').trim()
+        } catch (error) {
+          // File doesn't exist yet, that's fine
+        }
+
+        // Add a separator if the file already has content
+        const separator = existingContent ? '\n\n' : ''
+
+        // Combine everything and write to file
+        const newContent = `${existingContent}${separator}${interpreted}${timestamp}`
+        writeFileSync(file.path, newContent, 'utf-8')
+        updatedFiles.push(file.name)
+      } catch (error) {
+        logError(error)
+        console.error(
+          chalk.hex(getTheme().error)(
+            `Failed to update ${file.name}: ${error.message}`,
+          ),
+        )
+      }
+    }
+
+    if (updatedFiles.length > 0) {
+      console.log(
+        chalk.hex(getTheme().success)(
+          `Added note to ${updatedFiles.join(' and ')}`,
+        ),
+      )
+    }
+  } catch (e) {
+    logError(e)
+    console.error(
+      chalk.hex(getTheme().error)(`Failed to add note: ${e.message}`),
+    )
+  }
+}
+
+export default terminalSetup
+
+async function installBindingsForITerm2(): Promise<string> {
+  const { code } = await execFileNoThrow('defaults', [
+    'write',
+    'com.googlecode.iterm2',
+    'GlobalKeyMap',
+    '-dict-add',
+    '0xd-0x20000-0x24',
+    `<dict>
+      <key>Text</key>
+      <string>\\n</string>
+      <key>Action</key>
+      <integer>12</integer>
+      <key>Version</key>
+      <integer>1</integer>
+      <key>Keycode</key>
+      <integer>13</integer>
+      <key>Modifiers</key>
+      <integer>131072</integer>
+    </dict>`,
+  ])
+
+  if (code !== 0) {
+    throw new Error('Failed to install iTerm2 Shift+Enter key binding')
+  }
+
+  return `${chalk.hex(getTheme().success)(
+    'Installed iTerm2 Shift+Enter key binding',
+  )}${EOL}${chalk.dim('See iTerm2 → Preferences → Keys')}${EOL}`
+}
+
+type VSCodeKeybinding = {
+  key: string
+  command: string
+  args: { text: string }
+  when: string
+}
+
+function installBindingsForVSCodeTerminal(): string {
+  const vscodeKeybindingsPath = join(
+    homedir(),
+    platform() === 'win32'
+      ? join('AppData', 'Roaming', 'Code', 'User')
+      : platform() === 'darwin'
+        ? join('Library', 'Application Support', 'Code', 'User')
+        : join('.config', 'Code', 'User'),
+    'keybindings.json',
+  )
+
+  try {
+    const content = readFileSync(vscodeKeybindingsPath, 'utf-8')
+    const keybindings: VSCodeKeybinding[] =
+      (safeParseJSON(content) as VSCodeKeybinding[]) ?? []
+
+    // Check if keybinding already exists
+    const existingBinding = keybindings.find(
+      binding =>
+        binding.key === 'shift+enter' &&
+        binding.command === 'workbench.action.terminal.sendSequence' &&
+        binding.when === 'terminalFocus',
+    )
+    if (existingBinding) {
+      return `${chalk.hex(getTheme().warning)(
+        'Found existing VSCode terminal Shift+Enter key binding. Remove it to continue.',
+      )}${EOL}${chalk.dim(`See ${vscodeKeybindingsPath}`)}${EOL}`
+    }
+
+    // Add the keybinding
+    keybindings.push({
+      key: 'shift+enter',
+      command: 'workbench.action.terminal.sendSequence',
+      args: { text: '\\\r\n' },
+      when: 'terminalFocus',
+    })
+
+    writeFileSync(
+      vscodeKeybindingsPath,
+      JSON.stringify(keybindings, null, 4),
+      'utf-8',
+    )
+
+    return `${chalk.hex(getTheme().success)(
+      'Installed VSCode terminal Shift+Enter key binding',
+    )}${EOL}${chalk.dim(`See ${vscodeKeybindingsPath}`)}${EOL}`
+  } catch (e) {
+    logError(e)
+    throw new Error('Failed to install VSCode terminal Shift+Enter key binding')
+  }
+}

package/src/commands.ts

@@ -0,0 +1,136 @@
+import bug from './commands/bug'
+import clear from './commands/clear'
+import compact from './commands/compact'
+import config from './commands/config'
+import cost from './commands/cost'
+import ctx_viz from './commands/ctx_viz'
+import doctor from './commands/doctor'
+import help from './commands/help'
+import init from './commands/init'
+import listen from './commands/listen'
+import login from './commands/login'
+import logout from './commands/logout'
+import mcp from './commands/mcp'
+import * as model from './commands/model'
+import modelstatus from './commands/modelstatus'
+import onboarding from './commands/onboarding'
+import pr_comments from './commands/pr_comments'
+import refreshCommands from './commands/refreshCommands'
+import releaseNotes from './commands/release-notes'
+import review from './commands/review'
+import terminalSetup from './commands/terminalSetup'
+import { Tool, ToolUseContext } from './Tool'
+import resume from './commands/resume'
+import { getMCPCommands } from './services/mcpClient'
+import { loadCustomCommands } from './services/customCommands'
+import type { MessageParam } from '@anthropic-ai/sdk/resources/index.mjs'
+import { memoize } from 'lodash-es'
+import type { Message } from './query'
+import { isAnthropicAuthEnabled } from './utils/auth'
+
+type PromptCommand = {
+  type: 'prompt'
+  progressMessage: string
+  argNames?: string[]
+  getPromptForCommand(args: string): Promise<MessageParam[]>
+}
+
+type LocalCommand = {
+  type: 'local'
+  call(
+    args: string,
+    context: {
+      options: {
+        commands: Command[]
+        tools: Tool[]
+        slowAndCapableModel: string
+      }
+      abortController: AbortController
+      setForkConvoWithMessagesOnTheNextRender: (
+        forkConvoWithMessages: Message[],
+      ) => void
+    },
+  ): Promise<string>
+}
+
+type LocalJSXCommand = {
+  type: 'local-jsx'
+  call(
+    onDone: (result?: string) => void,
+    context: ToolUseContext & {
+      setForkConvoWithMessagesOnTheNextRender: (
+        forkConvoWithMessages: Message[],
+      ) => void
+    },
+  ): Promise<React.ReactNode>
+}
+
+export type Command = {
+  description: string
+  isEnabled: boolean
+  isHidden: boolean
+  name: string
+  aliases?: string[]
+  userFacingName(): string
+} & (PromptCommand | LocalCommand | LocalJSXCommand)
+
+const INTERNAL_ONLY_COMMANDS = [ctx_viz, resume, listen]
+
+// Declared as a function so that we don't run this until getCommands is called,
+// since underlying functions read from config, which can't be read at module initialization time
+const COMMANDS = memoize((): Command[] => [
+  clear,
+  compact,
+  config,
+  cost,
+  doctor,
+  help,
+  init,
+  mcp,
+  model,
+  modelstatus,
+  onboarding,
+  pr_comments,
+  refreshCommands,
+  releaseNotes,
+  bug,
+  review,
+  terminalSetup,
+  ...(isAnthropicAuthEnabled() ? [logout, login()] : []),
+  ...INTERNAL_ONLY_COMMANDS,
+])
+
+export const getCommands = memoize(async (): Promise<Command[]> => {
+  const [mcpCommands, customCommands] = await Promise.all([
+    getMCPCommands(),
+    loadCustomCommands(),
+  ])
+
+  return [...mcpCommands, ...customCommands, ...COMMANDS()].filter(
+    _ => _.isEnabled,
+  )
+})
+
+export function hasCommand(commandName: string, commands: Command[]): boolean {
+  return commands.some(
+    _ => _.userFacingName() === commandName || _.aliases?.includes(commandName),
+  )
+}
+
+export function getCommand(commandName: string, commands: Command[]): Command {
+  const command = commands.find(
+    _ => _.userFacingName() === commandName || _.aliases?.includes(commandName),
+  ) as Command | undefined
+  if (!command) {
+    throw ReferenceError(
+      `Command ${commandName} not found. Available commands: ${commands
+        .map(_ => {
+          const name = _.userFacingName()
+          return _.aliases ? `${name} (aliases: ${_.aliases.join(', ')})` : name
+        })
+        .join(', ')}`,
+    )
+  }
+
+  return command
+}

package/src/components/ApproveApiKey.tsx

@@ -0,0 +1,93 @@
+import React from 'react'
+import { Box, Text } from 'ink'
+import { getGlobalConfig, saveGlobalConfig } from '../utils/config'
+import { getTheme } from '../utils/theme'
+import { Select } from '@inkjs/ui'
+import { useExitOnCtrlCD } from '../hooks/useExitOnCtrlCD'
+import chalk from 'chalk'
+
+type Props = {
+  customApiKeyTruncated: string
+  onDone(): void
+}
+
+export function ApproveApiKey({
+  customApiKeyTruncated,
+  onDone,
+}: Props): React.ReactNode {
+  const theme = getTheme()
+
+  function onChange(value: 'yes' | 'no') {
+    const config = getGlobalConfig()
+    switch (value) {
+      case 'yes': {
+        saveGlobalConfig({
+          ...config,
+          customApiKeyResponses: {
+            ...config.customApiKeyResponses,
+            approved: [
+              ...(config.customApiKeyResponses?.approved ?? []),
+              customApiKeyTruncated,
+            ],
+          },
+        })
+        onDone()
+        break
+      }
+      case 'no': {
+        saveGlobalConfig({
+          ...config,
+          customApiKeyResponses: {
+            ...config.customApiKeyResponses,
+            rejected: [
+              ...(config.customApiKeyResponses?.rejected ?? []),
+              customApiKeyTruncated,
+            ],
+          },
+        })
+        onDone()
+        break
+      }
+    }
+  }
+
+  const exitState = useExitOnCtrlCD(() => process.exit(0))
+
+  return (
+    <>
+      <Box
+        flexDirection="column"
+        gap={1}
+        padding={1}
+        borderStyle="round"
+        borderColor={theme.warning}
+      >
+        <Text bold color={theme.warning}>
+          Detected a custom API key in your environment
+        </Text>
+        <Text>
+          Your environment sets{' '}
+          <Text color={theme.warning}>ANTHROPIC_API_KEY</Text>:{' '}
+          <Text bold>sk-ant-...{customApiKeyTruncated}</Text>
+        </Text>
+        <Text>Do you want to use this API key?</Text>
+        <Select
+          options={[
+            { label: `No (${chalk.bold('recommended')})`, value: 'no' },
+            { label: 'Yes', value: 'yes' },
+          ]}
+          onChange={value => onChange(value as 'yes' | 'no')}
+        />
+      </Box>
+      <Box marginLeft={3}>
+        <Text dimColor>
+          {exitState.pending ? (
+            <>Press {exitState.keyName} again to exit</>
+          ) : (
+            <>Enter to confirm</>
+          )}
+        </Text>
+      </Box>
+    </>
+  )
+}

package/src/components/AsciiLogo.tsx

@@ -0,0 +1,13 @@
+import { Box, Text } from 'ink'
+import React from 'react'
+import { getTheme } from '../utils/theme'
+import { ASCII_LOGO } from '../constants/product'
+
+export function AsciiLogo(): React.ReactNode {
+  const theme = getTheme()
+  return (
+    <Box flexDirection="column" alignItems="flex-start">
+      <Text color={theme.claude}>{ASCII_LOGO}</Text>
+    </Box>
+  )
+}