@shareai-lab/kode 1.1.13 → 1.1.16

package/src/utils/log.ts

@@ -1,382 +0,0 @@
-import { existsSync, mkdirSync } from 'fs'
-import { dirname, join } from 'path'
-import { writeFileSync, readFileSync } from 'fs'
-import { captureException } from '../services/sentry'
-import { randomUUID } from 'crypto'
-import envPaths from 'env-paths'
-import { promises as fsPromises } from 'fs'
-import type { LogOption, SerializedMessage } from '../types/logs'
-import { MACRO } from '../constants/macros'
-import { PRODUCT_COMMAND } from '../constants/product'
-const IN_MEMORY_ERROR_LOG: Array<{
-  error: string
-  timestamp: string
-}> = []
-const MAX_IN_MEMORY_ERRORS = 100 // Limit to prevent memory issues
-
-export const SESSION_ID = randomUUID()
-
-const paths = envPaths(PRODUCT_COMMAND)
-
-function getProjectDir(cwd: string): string {
-  return cwd.replace(/[^a-zA-Z0-9]/g, '-')
-}
-
-export const CACHE_PATHS = {
-  errors: () => join(paths.cache, getProjectDir(process.cwd()), 'errors'),
-  messages: () => join(paths.cache, getProjectDir(process.cwd()), 'messages'),
-  mcpLogs: (serverName: string) =>
-    join(paths.cache, getProjectDir(process.cwd()), `mcp-logs-${serverName}`),
-}
-
-export function dateToFilename(date: Date): string {
-  return date.toISOString().replace(/[:.]/g, '-')
-}
-
-const DATE = dateToFilename(new Date())
-
-function getErrorsPath(): string {
-  return join(CACHE_PATHS.errors(), DATE + '.txt')
-}
-
-export function getMessagesPath(
-  messageLogName: string,
-  forkNumber: number,
-  sidechainNumber: number,
-): string {
-  return join(
-    CACHE_PATHS.messages(),
-    `${messageLogName}${forkNumber > 0 ? `-${forkNumber}` : ''}${
-      sidechainNumber > 0 ? `-sidechain-${sidechainNumber}` : ''
-    }.json`,
-  )
-}
-
-export function logError(error: unknown): void {
-  try {
-    if (process.env.NODE_ENV === 'test') {
-      console.error(error)
-    }
-
-    const errorStr =
-      error instanceof Error ? error.stack || error.message : String(error)
-
-    const errorInfo = {
-      error: errorStr,
-      timestamp: new Date().toISOString(),
-    }
-
-    if (IN_MEMORY_ERROR_LOG.length >= MAX_IN_MEMORY_ERRORS) {
-      IN_MEMORY_ERROR_LOG.shift() // Remove oldest error
-    }
-    IN_MEMORY_ERROR_LOG.push(errorInfo)
-
-    appendToLog(getErrorsPath(), {
-      error: errorStr,
-    })
-  } catch {
-    // pass
-  }
-  // Also send to Sentry with session ID, but don't await
-  captureException(error)
-}
-
-export function getErrorsLog(): object[] {
-  return readLog(getErrorsPath())
-}
-
-export function getInMemoryErrors(): object[] {
-  return [...IN_MEMORY_ERROR_LOG]
-}
-
-function readLog(path: string): object[] {
-  if (!existsSync(path)) {
-    return []
-  }
-  try {
-    return JSON.parse(readFileSync(path, 'utf8'))
-  } catch {
-    return []
-  }
-}
-
-function appendToLog(path: string, message: object): void {
-  if (process.env.USER_TYPE === 'external') {
-    return
-  }
-
-  const dir = dirname(path)
-  if (!existsSync(dir)) {
-    mkdirSync(dir, { recursive: true })
-  }
-
-  // Create messages file with empty array if it doesn't exist
-  if (!existsSync(path)) {
-    writeFileSync(path, '[]', 'utf8')
-  }
-
-  const messages = readLog(path)
-  const messageWithTimestamp = {
-    ...message,
-    cwd: process.cwd(),
-    userType: process.env.USER_TYPE,
-    sessionId: SESSION_ID,
-    timestamp: new Date().toISOString(),
-    version: MACRO.VERSION,
-  }
-  messages.push(messageWithTimestamp)
-
-  writeFileSync(path, JSON.stringify(messages, null, 2), 'utf8')
-}
-
-export function overwriteLog(path: string, messages: object[]): void {
-  if (process.env.USER_TYPE === 'external') {
-    return
-  }
-
-  if (!messages.length) {
-    return
-  }
-
-  const dir = dirname(path)
-  if (!existsSync(dir)) {
-    mkdirSync(dir, { recursive: true })
-  }
-
-  const messagesWithMetadata = messages.map(message => ({
-    ...message,
-    cwd: process.cwd(),
-    userType: process.env.USER_TYPE,
-    sessionId: SESSION_ID,
-    timestamp: new Date().toISOString(),
-    version: MACRO.VERSION,
-  }))
-
-  writeFileSync(path, JSON.stringify(messagesWithMetadata, null, 2), 'utf8')
-}
-
-export async function loadLogList(
-  path = CACHE_PATHS.messages(),
-): Promise<LogOption[]> {
-  if (!existsSync(path)) {
-    logError(`No logs found at ${path}`)
-    return []
-  }
-
-  const files = await fsPromises.readdir(path)
-  const logData = await Promise.all(
-    files.map(async (file, i) => {
-      const fullPath = join(path, file)
-      const content = await fsPromises.readFile(fullPath, 'utf8')
-      const messages = JSON.parse(content) as SerializedMessage[]
-      const firstMessage = messages[0]
-      const lastMessage = messages[messages.length - 1]
-      const firstPrompt =
-        firstMessage?.type === 'user' &&
-        typeof firstMessage?.message?.content === 'string'
-          ? firstMessage?.message?.content
-          : 'No prompt'
-
-      const { date, forkNumber, sidechainNumber } = parseLogFilename(file)
-      return {
-        date,
-        forkNumber,
-        fullPath,
-        messages,
-        value: i, // hack: overwritten after sorting, right below this
-        created: parseISOString(firstMessage?.timestamp || date),
-        modified: lastMessage?.timestamp
-          ? parseISOString(lastMessage.timestamp)
-          : parseISOString(date),
-        firstPrompt:
-          firstPrompt.split('\n')[0]?.slice(0, 50) +
-            (firstPrompt.length > 50 ? '…' : '') || 'No prompt',
-        messageCount: messages.length,
-        sidechainNumber,
-      }
-    }),
-  )
-
-  return sortLogs(logData.filter(_ => _.messages.length)).map((_, i) => ({
-    ..._,
-    value: i,
-  }))
-}
-
-export function parseLogFilename(filename: string): {
-  date: string
-  forkNumber: number | undefined
-  sidechainNumber: number | undefined
-} {
-  const base = filename.split('.')[0]!
-  // Default timestamp format has 6 segments: 2025-01-27T01-31-35-104Z
-  const segments = base.split('-')
-  const hasSidechain = base.includes('-sidechain-')
-
-  let date = base
-  let forkNumber: number | undefined = undefined
-  let sidechainNumber: number | undefined = undefined
-
-  if (hasSidechain) {
-    const sidechainIndex = segments.indexOf('sidechain')
-    sidechainNumber = Number(segments[sidechainIndex + 1])
-    // Fork number is before sidechain if exists
-    if (sidechainIndex > 6) {
-      forkNumber = Number(segments[sidechainIndex - 1])
-      date = segments.slice(0, 6).join('-')
-    } else {
-      date = segments.slice(0, 6).join('-')
-    }
-  } else if (segments.length > 6) {
-    // Has fork number
-    const lastSegment = Number(segments[segments.length - 1])
-    forkNumber = lastSegment >= 0 ? lastSegment : undefined
-    date = segments.slice(0, 6).join('-')
-  } else {
-    // Basic timestamp only
-    date = base
-  }
-
-  return { date, forkNumber, sidechainNumber }
-}
-
-export function getNextAvailableLogForkNumber(
-  date: string,
-  forkNumber: number,
-  // Main chain has sidechainNumber 0
-  sidechainNumber: number,
-): number {
-  while (existsSync(getMessagesPath(date, forkNumber, sidechainNumber))) {
-    forkNumber++
-  }
-  return forkNumber
-}
-
-export function getNextAvailableLogSidechainNumber(
-  date: string,
-  forkNumber: number,
-): number {
-  let sidechainNumber = 1
-  while (existsSync(getMessagesPath(date, forkNumber, sidechainNumber))) {
-    sidechainNumber++
-  }
-  return sidechainNumber
-}
-
-export function getForkNumberFromFilename(
-  filename: string,
-): number | undefined {
-  const base = filename.split('.')[0]!
-  const segments = base.split('-')
-  const hasSidechain = base.includes('-sidechain-')
-
-  if (hasSidechain) {
-    const sidechainIndex = segments.indexOf('sidechain')
-    if (sidechainIndex > 6) {
-      return Number(segments[sidechainIndex - 1])
-    }
-    return undefined
-  }
-
-  if (segments.length > 6) {
-    const lastNumber = Number(segments[segments.length - 1])
-    return lastNumber >= 0 ? lastNumber : undefined
-  }
-  return undefined
-}
-
-export function sortLogs(logs: LogOption[]): LogOption[] {
-  return logs.sort((a, b) => {
-    // Sort by modified date (newest first)
-    const modifiedDiff = b.modified.getTime() - a.modified.getTime()
-    if (modifiedDiff !== 0) {
-      return modifiedDiff
-    }
-
-    // If modified dates are equal, sort by created date
-    const createdDiff = b.created.getTime() - a.created.getTime()
-    if (createdDiff !== 0) {
-      return createdDiff
-    }
-
-    // If both dates are equal, sort by fork number
-    return (b.forkNumber ?? 0) - (a.forkNumber ?? 0)
-  })
-}
-
-export function formatDate(date: Date): string {
-  const now = new Date()
-  const yesterday = new Date(now)
-  yesterday.setDate(yesterday.getDate() - 1)
-
-  const isToday = date.toDateString() === now.toDateString()
-  const isYesterday = date.toDateString() === yesterday.toDateString()
-
-  const timeStr = date
-    .toLocaleTimeString('en-US', {
-      hour: 'numeric',
-      minute: '2-digit',
-      hour12: true,
-    })
-    .toLowerCase()
-
-  if (isToday) {
-    return `Today at ${timeStr}`
-  } else if (isYesterday) {
-    return `Yesterday at ${timeStr}`
-  } else {
-    return (
-      date.toLocaleDateString('en-US', {
-        month: 'short',
-        day: 'numeric',
-      }) + ` at ${timeStr}`
-    )
-  }
-}
-
-export function parseISOString(s: string): Date {
-  const b = s.split(/\D+/)
-  return new Date(
-    Date.UTC(
-      parseInt(b[0]!, 10),
-      parseInt(b[1]!, 10) - 1,
-      parseInt(b[2]!, 10),
-      parseInt(b[3]!, 10),
-      parseInt(b[4]!, 10),
-      parseInt(b[5]!, 10),
-      parseInt(b[6]!, 10),
-    ),
-  )
-}
-
-export function logMCPError(serverName: string, error: unknown): void {
-  try {
-    const logDir = CACHE_PATHS.mcpLogs(serverName)
-    const errorStr =
-      error instanceof Error ? error.stack || error.message : String(error)
-    const timestamp = new Date().toISOString()
-
-    const logFile = join(logDir, DATE + '.txt')
-
-    if (!existsSync(logDir)) {
-      mkdirSync(logDir, { recursive: true })
-    }
-
-    if (!existsSync(logFile)) {
-      writeFileSync(logFile, '[]', 'utf8')
-    }
-
-    const errorInfo = {
-      error: errorStr,
-      timestamp,
-      sessionId: SESSION_ID,
-      cwd: process.cwd(),
-    }
-
-    const messages = readLog(logFile)
-    messages.push(errorInfo)
-    writeFileSync(logFile, JSON.stringify(messages, null, 2), 'utf8')
-  } catch {
-    // Silently fail
-  }
-}

package/src/utils/markdown.ts

@@ -1,213 +0,0 @@
-import { marked, Token } from 'marked'
-import { stripSystemMessages } from './messages'
-import chalk from 'chalk'
-import { EOL } from 'os'
-import { highlight, supportsLanguage } from 'cli-highlight'
-import { logError } from './log'
-
-export function applyMarkdown(content: string): string {
-  return marked
-    .lexer(stripSystemMessages(content))
-    .map(_ => format(_))
-    .join('')
-    .trim()
-}
-
-function format(
-  token: Token,
-  listDepth = 0,
-  orderedListNumber: number | null = null,
-  parent: Token | null = null,
-): string {
-  switch (token.type) {
-    case 'blockquote':
-      return chalk.dim.italic((token.tokens ?? []).map(_ => format(_)).join(''))
-    case 'code':
-      if (token.lang && supportsLanguage(token.lang)) {
-        return highlight(token.text, { language: token.lang }) + EOL
-      } else {
-        logError(
-          `Language not supported while highlighting code, falling back to markdown: ${token.lang}`,
-        )
-        return highlight(token.text, { language: 'markdown' }) + EOL
-      }
-    case 'codespan':
-      // inline code
-      return chalk.blue(token.text)
-    case 'em':
-      return chalk.italic((token.tokens ?? []).map(_ => format(_)).join(''))
-    case 'strong':
-      return chalk.bold((token.tokens ?? []).map(_ => format(_)).join(''))
-    case 'heading':
-      switch (token.depth) {
-        case 1: // h1
-          return (
-            chalk.bold.italic.underline(
-              (token.tokens ?? []).map(_ => format(_)).join(''),
-            ) +
-            EOL +
-            EOL
-          )
-        case 2: // h2
-          return (
-            chalk.bold((token.tokens ?? []).map(_ => format(_)).join('')) +
-            EOL +
-            EOL
-          )
-        default: // h3+
-          return (
-            chalk.bold.dim((token.tokens ?? []).map(_ => format(_)).join('')) +
-            EOL +
-            EOL
-          )
-      }
-    case 'hr':
-      return '---'
-    case 'image':
-      return `[Image: ${token.title}: ${token.href}]`
-    case 'link':
-      return chalk.blue(token.href)
-    case 'list': {
-      return token.items
-        .map((_: Token, index: number) =>
-          format(
-            _,
-            listDepth,
-            token.ordered ? token.start + index : null,
-            token,
-          ),
-        )
-        .join('')
-    }
-    case 'list_item':
-      return (token.tokens ?? [])
-        .map(
-          _ =>
-            `${'  '.repeat(listDepth)}${format(_, listDepth + 1, orderedListNumber, token)}`,
-        )
-        .join('')
-    case 'paragraph':
-      return (token.tokens ?? []).map(_ => format(_)).join('') + EOL
-    case 'space':
-      return EOL
-    case 'text':
-      if (parent?.type === 'list_item') {
-        return `${orderedListNumber === null ? '-' : getListNumber(listDepth, orderedListNumber) + '.'} ${token.tokens ? token.tokens.map(_ => format(_, listDepth, orderedListNumber, token)).join('') : token.text}${EOL}`
-      } else {
-        return token.text
-      }
-  }
-  // TODO: tables
-  return ''
-}
-
-const DEPTH_1_LIST_NUMBERS = [
-  'a',
-  'b',
-  'c',
-  'd',
-  'e',
-  'f',
-  'g',
-  'h',
-  'i',
-  'j',
-  'k',
-  'l',
-  'm',
-  'n',
-  'o',
-  'p',
-  'q',
-  'r',
-  's',
-  't',
-  'u',
-  'v',
-  'w',
-  'x',
-  'y',
-  'z',
-  'aa',
-  'ab',
-  'ac',
-  'ad',
-  'ae',
-  'af',
-  'ag',
-  'ah',
-  'ai',
-  'aj',
-  'ak',
-  'al',
-  'am',
-  'an',
-  'ao',
-  'ap',
-  'aq',
-  'ar',
-  'as',
-  'at',
-  'au',
-  'av',
-  'aw',
-  'ax',
-  'ay',
-  'az',
-]
-const DEPTH_2_LIST_NUMBERS = [
-  'i',
-  'ii',
-  'iii',
-  'iv',
-  'v',
-  'vi',
-  'vii',
-  'viii',
-  'ix',
-  'x',
-  'xi',
-  'xii',
-  'xiii',
-  'xiv',
-  'xv',
-  'xvi',
-  'xvii',
-  'xviii',
-  'xix',
-  'xx',
-  'xxi',
-  'xxii',
-  'xxiii',
-  'xxiv',
-  'xxv',
-  'xxvi',
-  'xxvii',
-  'xxviii',
-  'xxix',
-  'xxx',
-  'xxxi',
-  'xxxii',
-  'xxxiii',
-  'xxxiv',
-  'xxxv',
-  'xxxvi',
-  'xxxvii',
-  'xxxviii',
-  'xxxix',
-  'xl',
-]
-
-function getListNumber(listDepth: number, orderedListNumber: number): string {
-  switch (listDepth) {
-    case 0:
-    case 1:
-      return orderedListNumber.toString()
-    case 2:
-      return DEPTH_1_LIST_NUMBERS[orderedListNumber - 1]! // TODO: don't hard code the list
-    case 3:
-      return DEPTH_2_LIST_NUMBERS[orderedListNumber - 1]! // TODO: don't hard code the list
-    default:
-      return orderedListNumber.toString()
-  }
-}