@shareai-lab/kode 1.0.69 → 1.0.71

package/src/utils/diff.ts

@@ -0,0 +1,42 @@
+import { type Hunk, structuredPatch } from 'diff'
+
+const CONTEXT_LINES = 3
+
+// For some reason, & confuses the diff library, so we replace it with a token,
+// then substitute it back in after the diff is computed.
+const AMPERSAND_TOKEN = '<<:AMPERSAND_TOKEN:>>'
+
+const DOLLAR_TOKEN = '<<:DOLLAR_TOKEN:>>'
+
+export function getPatch({
+  filePath,
+  fileContents,
+  oldStr,
+  newStr,
+}: {
+  filePath: string
+  fileContents: string
+  oldStr: string
+  newStr: string
+}): Hunk[] {
+  return structuredPatch(
+    filePath,
+    filePath,
+    fileContents.replaceAll('&', AMPERSAND_TOKEN).replaceAll('$', DOLLAR_TOKEN),
+    fileContents
+      .replaceAll('&', AMPERSAND_TOKEN)
+      .replaceAll('$', DOLLAR_TOKEN)
+      .replace(
+        oldStr.replaceAll('&', AMPERSAND_TOKEN).replaceAll('$', DOLLAR_TOKEN),
+        newStr.replaceAll('&', AMPERSAND_TOKEN).replaceAll('$', DOLLAR_TOKEN),
+      ),
+    undefined,
+    undefined,
+    { context: CONTEXT_LINES },
+  ).hunks.map(_ => ({
+    ..._,
+    lines: _.lines.map(_ =>
+      _.replaceAll(AMPERSAND_TOKEN, '&').replaceAll(DOLLAR_TOKEN, '$'),
+    ),
+  }))
+}

package/src/utils/env.ts

@@ -0,0 +1,57 @@
+import { execFileNoThrow } from './execFileNoThrow'
+import { memoize } from 'lodash-es'
+import { join } from 'path'
+import { homedir } from 'os'
+import { CONFIG_BASE_DIR, CONFIG_FILE } from '../constants/product'
+// Base directory for all Any kode data files (except config.json for backwards compatibility)
+// Support both KODE_CONFIG_DIR and CLAUDE_CONFIG_DIR for compatibility
+export const CLAUDE_BASE_DIR =
+  process.env.KODE_CONFIG_DIR ?? process.env.CLAUDE_CONFIG_DIR ?? join(homedir(), CONFIG_BASE_DIR)
+
+// Config and data paths
+// Support both KODE_CONFIG_DIR and CLAUDE_CONFIG_DIR environment variables
+export const GLOBAL_CLAUDE_FILE = (process.env.KODE_CONFIG_DIR || process.env.CLAUDE_CONFIG_DIR)
+  ? join(CLAUDE_BASE_DIR, 'config.json')
+  : join(homedir(), CONFIG_FILE)
+export const MEMORY_DIR = join(CLAUDE_BASE_DIR, 'memory')
+
+const getIsDocker = memoize(async (): Promise<boolean> => {
+  // Check for .dockerenv file
+  const { code } = await execFileNoThrow('test', ['-f', '/.dockerenv'])
+  if (code !== 0) {
+    return false
+  }
+  return process.platform === 'linux'
+})
+
+const hasInternetAccess = memoize(async (): Promise<boolean> => {
+  try {
+    const controller = new AbortController()
+    const timeout = setTimeout(() => controller.abort(), 1000)
+
+    await fetch('http://1.1.1.1', {
+      method: 'HEAD',
+      signal: controller.signal,
+    })
+
+    clearTimeout(timeout)
+    return true
+  } catch {
+    return false
+  }
+})
+
+// all of these should be immutable
+export const env = {
+  getIsDocker,
+  hasInternetAccess,
+  isCI: Boolean(process.env.CI),
+  platform:
+    process.platform === 'win32'
+      ? 'windows'
+      : process.platform === 'darwin'
+        ? 'macos'
+        : 'linux',
+  nodeVersion: process.version,
+  terminal: process.env.TERM_PROGRAM,
+}

package/src/utils/errors.ts

@@ -0,0 +1,21 @@
+export class MalformedCommandError extends TypeError {}
+
+export class DeprecatedCommandError extends Error {}
+
+export class AbortError extends Error {}
+
+/**
+ * Custom error class for configuration file parsing errors
+ * Includes the file path and the default configuration that should be used
+ */
+export class ConfigParseError extends Error {
+  filePath: string
+  defaultConfig: unknown
+
+  constructor(message: string, filePath: string, defaultConfig: unknown) {
+    super(message)
+    this.name = 'ConfigParseError'
+    this.filePath = filePath
+    this.defaultConfig = defaultConfig
+  }
+}

package/src/utils/exampleCommands.ts

@@ -0,0 +1,108 @@
+import {
+  getGlobalConfig,
+  saveGlobalConfig,
+  getCurrentProjectConfig,
+  saveCurrentProjectConfig,
+} from './config.js'
+import { env } from './env'
+import { getCwd } from './state'
+import { exec } from 'child_process'
+import { logError } from './log'
+import { memoize, sample } from 'lodash-es'
+import { promisify } from 'util'
+import { getIsGit } from './git'
+
+const execPromise = promisify(exec)
+
+async function getFrequentlyModifiedFiles(): Promise<string[]> {
+  if (process.env.NODE_ENV === 'test') return []
+  if (env.platform === 'windows') return []
+  if (!(await getIsGit())) return []
+
+  try {
+    let filenames = ''
+    // Look up files modified by the user's recent commits
+    // Be careful to do it async, so it doesn't block the main thread
+    const { stdout: userFilenames } = await execPromise(
+      'git log -n 1000 --pretty=format: --name-only --diff-filter=M --author=$(git config user.email) | sort | uniq -c | sort -nr | head -n 20',
+      { cwd: getCwd(), encoding: 'utf8' },
+    )
+
+    filenames = 'Files modified by user:\n' + userFilenames
+
+    // Look at other users' commits if we don't have enough files
+    if (userFilenames.split('\n').length < 10) {
+      const { stdout: allFilenames } = await execPromise(
+        'git log -n 1000 --pretty=format: --name-only --diff-filter=M | sort | uniq -c | sort -nr | head -n 20',
+        { cwd: getCwd(), encoding: 'utf8' },
+      )
+      filenames += '\n\nFiles modified by other users:\n' + allFilenames
+    }
+    const response = await queryQuick({
+      systemPrompt: [
+        "You are an expert at analyzing git history. Given a list of files and their modification counts, return exactly five filenames that are frequently modified and represent core application logic (not auto-generated files, dependencies, or configuration). Make sure filenames are diverse, not all in the same folder, and are a mix of user and other users. Return only the filenames' basenames (without the path) separated by newlines with no explanation.",
+      ],
+      userPrompt: filenames,
+    })
+
+    const content = response.message.content[0]
+    if (!content || content.type !== 'text') return []
+    const chosenFilenames = content.text.trim().split('\n')
+    if (chosenFilenames.length < 5) {
+      // Likely error
+      return []
+    }
+    return chosenFilenames
+  } catch (err) {
+    logError(err)
+    return []
+  }
+}
+
+export const getExampleCommands = memoize(async (): Promise<string[]> => {
+  const globalConfig = getGlobalConfig()
+  const projectConfig = getCurrentProjectConfig()
+  const now = Date.now()
+  const lastGenerated = projectConfig.exampleFilesGeneratedAt ?? 0
+  const oneWeek = 7 * 24 * 60 * 60 * 1000
+
+  // Regenerate examples if they're over a week old
+  if (now - lastGenerated > oneWeek) {
+    projectConfig.exampleFiles = []
+  }
+
+  // Update global startup count
+  const newGlobalConfig = {
+    ...globalConfig,
+    numStartups: (globalConfig.numStartups ?? 0) + 1,
+  }
+  saveGlobalConfig(newGlobalConfig)
+
+  // // If no example files cached, kickstart fetch in background
+  // if (!projectConfig.exampleFiles?.length) {
+  //   getFrequentlyModifiedFiles().then(files => {
+  //     if (files.length) {
+  //       saveCurrentProjectConfig({
+  //         ...getCurrentProjectConfig(),
+  //         exampleFiles: files,
+  //         exampleFilesGeneratedAt: Date.now(),
+  //       })
+  //     }
+  //   })
+  // }
+
+  const frequentFile = projectConfig.exampleFiles?.length
+    ? sample(projectConfig.exampleFiles)
+    : '<filepath>'
+
+  return [
+    'fix lint errors',
+    'fix typecheck errors',
+    `how does ${frequentFile} work?`,
+    `refactor ${frequentFile}`,
+    'how do I log an error?',
+    `edit ${frequentFile} to...`,
+    `write a test for ${frequentFile}`,
+    'create a util logging.py that...',
+  ]
+})

package/src/utils/execFileNoThrow.ts

@@ -0,0 +1,51 @@
+import { execFile } from 'child_process'
+import { getCwd } from './state'
+import { logError } from './log'
+
+const MS_IN_SECOND = 1000
+const SECONDS_IN_MINUTE = 60
+
+/**
+ * execFile, but always resolves (never throws)
+ */
+export function execFileNoThrow(
+  file: string,
+  args: string[],
+  abortSignal?: AbortSignal,
+  timeout = 10 * SECONDS_IN_MINUTE * MS_IN_SECOND,
+  preserveOutputOnError = true,
+): Promise<{ stdout: string; stderr: string; code: number }> {
+  return new Promise(resolve => {
+    try {
+      execFile(
+        file,
+        args,
+        {
+          maxBuffer: 1_000_000,
+          signal: abortSignal,
+          timeout,
+          cwd: getCwd(),
+        },
+        (error, stdout, stderr) => {
+          if (error) {
+            if (preserveOutputOnError) {
+              const errorCode = typeof error.code === 'number' ? error.code : 1
+              resolve({
+                stdout: stdout || '',
+                stderr: stderr || '',
+                code: errorCode,
+              })
+            } else {
+              resolve({ stdout: '', stderr: '', code: 1 })
+            }
+          } else {
+            resolve({ stdout, stderr, code: 0 })
+          }
+        },
+      )
+    } catch (error) {
+      logError(error)
+      resolve({ stdout: '', stderr: '', code: 1 })
+    }
+  })
+}

package/src/utils/expertChatStorage.ts

@@ -0,0 +1,136 @@
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs'
+import { join } from 'path'
+import { homedir } from 'os'
+import { randomUUID } from 'crypto'
+
+/**
+ * Expert Chat Session Storage - 极简版
+ * 存储符合OpenAI格式的messages历史
+ */
+
+export interface ChatMessage {
+  role: 'user' | 'assistant'
+  content: string
+}
+
+export interface ExpertChatSession {
+  sessionId: string
+  expertModel: string
+  messages: ChatMessage[]
+  createdAt: number
+  lastUpdated: number
+}
+
+/**
+ * 获取专家聊天存储目录
+ */
+function getExpertChatDirectory(): string {
+  const configDir =
+    process.env.KODE_CONFIG_DIR ?? process.env.ANYKODE_CONFIG_DIR ?? join(homedir(), '.kode')
+  const expertChatDir = join(configDir, 'expert-chats')
+
+  if (!existsSync(expertChatDir)) {
+    mkdirSync(expertChatDir, { recursive: true })
+  }
+
+  return expertChatDir
+}
+
+/**
+ * 获取会话文件路径 - 使用 sessionId.json 格式
+ */
+function getSessionFilePath(sessionId: string): string {
+  return join(getExpertChatDirectory(), `${sessionId}.json`)
+}
+
+/**
+ * 创建新的专家聊天会话
+ */
+export function createExpertChatSession(
+  expertModel: string,
+): ExpertChatSession {
+  const sessionId = randomUUID().slice(0, 5)
+  const session: ExpertChatSession = {
+    sessionId,
+    expertModel,
+    messages: [],
+    createdAt: Date.now(),
+    lastUpdated: Date.now(),
+  }
+
+  saveExpertChatSession(session)
+  return session
+}
+
+/**
+ * 加载现有专家聊天会话
+ */
+export function loadExpertChatSession(
+  sessionId: string,
+): ExpertChatSession | null {
+  const filePath = getSessionFilePath(sessionId)
+
+  if (!existsSync(filePath)) {
+    return null
+  }
+
+  try {
+    const content = readFileSync(filePath, 'utf-8')
+    return JSON.parse(content) as ExpertChatSession
+  } catch (error) {
+    console.error(`Failed to load expert chat session ${sessionId}:`, error)
+    return null
+  }
+}
+
+/**
+ * 保存专家聊天会话
+ */
+export function saveExpertChatSession(session: ExpertChatSession): void {
+  const filePath = getSessionFilePath(session.sessionId)
+
+  try {
+    session.lastUpdated = Date.now()
+    writeFileSync(filePath, JSON.stringify(session, null, 2), 'utf-8')
+  } catch (error) {
+    console.error(
+      `Failed to save expert chat session ${session.sessionId}:`,
+      error,
+    )
+    throw error
+  }
+}
+
+/**
+ * 添加消息到会话
+ */
+export function addMessageToSession(
+  sessionId: string,
+  role: 'user' | 'assistant',
+  content: string,
+): ExpertChatSession | null {
+  const session = loadExpertChatSession(sessionId)
+  if (!session) {
+    return null
+  }
+
+  session.messages.push({ role, content })
+  saveExpertChatSession(session)
+
+  return session
+}
+
+/**
+ * 获取会话的消息历史 - 返回OpenAI格式
+ */
+export function getSessionMessages(sessionId: string): ChatMessage[] {
+  const session = loadExpertChatSession(sessionId)
+  return session?.messages || []
+}
+
+/**
+ * 生成新的会话ID
+ */
+export function generateSessionId(): string {
+  return randomUUID().slice(0, 5)
+}